@subiz/wsclient 3.1.1 → 3.1.7

package/.prettierrc.js

@@ -1,7 +1,19 @@
 module.exports = {
+	arrowParens: 'always',
 	bracketSpacing: false,
+	embeddedLanguageFormatting: 'auto',
+	htmlWhitespaceSensitivity: 'css',
+	insertPragma: false,
 	jsxBracketSameLine: true,
+	jsxSingleQuote: true,
+	printWidth: 120,
+	proseWrap: 'preserve',
+	quoteProps: 'as-needed',
+	requirePragma: false,
+	semi: false,
 	singleQuote: true,
+	tabWidth: 2,
 	trailingComma: 'all',
-	printWidth: 120,
+	useTabs: true,
+	vueIndentScriptAndStyle: false,
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@subiz/wsclient",
-	"version": "3.1.1",
+	"version": "3.1.7",
 	"main": "index.js",
 	"scripts": {
 		"test": "node realtime.test.js"
@@ -14,10 +14,9 @@
 	"homepage": "https://github.com/subiz/wsclient#readme",
 	"description": "",
 	"devDependencies": {
-		"axios": "^0.21.0",
-		"tape": "^5.0.1"
+		"tape": "^5.3.1"
 	},
 	"dependencies": {
-		"@subiz/flow": "^1.0.7"
+		"@subiz/flow": "^1.0.9"
 	}
 }

package/realtime.js

@@ -13,7 +13,7 @@ var flow = require('@subiz/flow')
 //
 // Once dead, onDead will be called. After that, the connection is
 // useless, all resources will be released.
-function Conn (apiUrl, credential, onDead, onEvents, callAPI) {
+function Conn(apiUrl, credential, onDead, onEvents, callAPI) {
 	callAPI = callAPI || xhrsend // allow hook
 	credential = credential || {}
 	// tell if connection is dead
@@ -22,7 +22,7 @@ function Conn (apiUrl, credential, onDead, onEvents, callAPI) {
 	var lastToken = ''
 
 	// kill force the connection to dead state
-	this.kill = function () {
+	this.kill = function() {
 		dead = true
 	}
 
@@ -31,9 +31,9 @@ function Conn (apiUrl, credential, onDead, onEvents, callAPI) {
 	// exponential backoff algorithm. Polling loop will terminate if it encounter an
 	// un-retryable error
 	// the polling loop starts after the first subscribe call finished successfully
-	var polling = function (backoff) {
+	var polling = function(backoff) {
 		if (dead) return
-		callAPI('get', apiUrl + 'poll?token=' + lastToken, undefined, function (body, code) {
+		callAPI('get', apiUrl + 'poll?token=' + lastToken, undefined, function(body, code) {
 			if (dead) return
 			if (retryable(code)) return setTimeout(polling, calcNextBackoff(backoff), backoff + 1)
 			if (code !== 200) {
@@ -55,20 +55,20 @@ function Conn (apiUrl, credential, onDead, onEvents, callAPI) {
 		})
 	}
 
-	var subQueue = flow.batch(50, 100, function (events) {
+	var subQueue = flow.batch(50, 100, function(events) {
 		if (dead) return ['dead']
 		if (events.length <= 0) return []
 
 		var out = []
-		return flow.
-			loop(function () {
-				return new Promise(function (rs) {
+		return flow
+			.loop(function() {
+				return new Promise(function(rs) {
 					var query = '?token=' + lastToken
-					credential.getAccessToken().then(function (access_token) {
+					credential.getAccessToken().then(function(access_token) {
 						if (credential.user_mask) query += '&user-mask=' + encodeURIComponent(credential.user_mask)
 						else if (access_token) query += '&access-token=' + access_token
 
-						callAPI('post', apiUrl + 'subs' + query, JSON.stringify({ events: events }), function (body, code) {
+						callAPI('post', apiUrl + 'subs' + query, JSON.stringify({events: events}), function(body, code) {
 							if (dead) {
 								out = repeat('dead', events.length)
 								return rs(false) // break loop
@@ -100,8 +100,8 @@ function Conn (apiUrl, credential, onDead, onEvents, callAPI) {
 						})
 					})
 				})
-			}).
-			then(function () {
+			})
+			.then(function() {
 				return out
 			})
 	})
@@ -119,11 +119,11 @@ function Conn (apiUrl, credential, onDead, onEvents, callAPI) {
 // additional features compare to conn:
 //   + auto recreate and resub if the last conn is dead
 //   + don't subscribe already subscribed events
-function Realtime (apiUrls, credential, callAPI) {
+function Realtime(apiUrls, credential, callAPI) {
 	if (typeof apiUrls === 'string' || apiUrls instanceof String) apiUrls = [apiUrls]
 	credential = credential || {}
 	if (!credential.getAccessToken) {
-		credential.getAccessToken = function () {
+		credential.getAccessToken = function() {
 			return Promise.resolve('')
 		}
 	}
@@ -140,36 +140,36 @@ function Realtime (apiUrls, credential, callAPI) {
 
 	// stop the connection
 	var stop = false
-	this.stop = function () {
+	this.stop = function() {
 		if (stop) return
 		stop = true
 		conn.kill()
 	}
 
-	this.onEvent = function (cb) {
+	this.onEvent = function(cb) {
 		return pubsub.on('event', cb)
 	}
 
-	this.onInterrupted = function (cb) {
+	this.onInterrupted = function(cb) {
 		return pubsub.on('interrupted', cb)
 	}
 
 	var conn
-	this.subscribe = function (events) {
+	this.subscribe = function(events) {
 		if (stop) return Promise.resolve({})
 		if (typeof events === 'string') events = [events]
-		if (!Array.isArray(events)) return Promise.resolve({ error: 'param should be an array or string' })
+		if (!Array.isArray(events)) return Promise.resolve({error: 'param should be an array or string'})
 
 		// ignore already subscribed events
 		var all = []
 		for (var i = 0; i < events.length; i++) {
 			var topic = events[i]
 			if (!topic) continue
-			if (topics[topic] !== 'online') all.push(conn.subscribe(topic))
+			if (!topics[topic]) all.push(conn.subscribe(topic))
 		}
 		if (all.length === 0) return Promise.resolve({})
-		return Promise.all(all).then(function (errs) {
-			for (var i = 0; i < errs.length; i++) if (errs[i]) return { error: errs[i] }
+		return Promise.all(all).then(function(errs) {
+			for (var i = 0; i < errs.length; i++) if (errs[i]) return {error: errs[i]}
 			for (var j = 0; j < events.length; j++) topics[events[j]] = true
 			return {}
 		})
@@ -177,7 +177,7 @@ function Realtime (apiUrls, credential, callAPI) {
 
 	// reconnect make sure there is alway a Conn running in the background
 	// if the Conn is dead, it recreate a new one
-	var reconnect = function () {
+	var reconnect = function() {
 		if (stop) return
 		// reset subscribed topic
 		var allTopics = Object.keys(topics)
@@ -187,12 +187,12 @@ function Realtime (apiUrls, credential, callAPI) {
 		conn = new Conn(
 			randomUrl,
 			credential,
-			function (code, body, status) {
+			function(code, body, status) {
 				if (stop) return
 				pubsub.emit('interrupted', code, body, status)
 				setTimeout(reconnect, 2000) // reconnect and resubscribe after 2 sec
 			},
-			function (topics) {
+			function(topics) {
 				if (stop) return
 				for (var i = 0; i < topics.length; i++) pubsub.emit('event', topics[i])
 			},
@@ -206,16 +206,28 @@ function Realtime (apiUrls, credential, callAPI) {
 	reconnect()
 }
 
+var dofetch = function(method, url, body, cb) {
+	let headers = {}
+	if (body) headers['content-type'] = 'text/plain'
+	fetch(url, {
+		method: method,
+		headers: headers,
+		body: body,
+	})
+		.then((res) => res.text().then((text) => cb && cb(text, res.status)))
+		.catch((err) => cb && cb(err, -1))
+}
 // xhrsend sends an HTTP request
-function xhrsend (method, url, body, cb) {
+var xhrsend = function(method, url, body, cb) {
+	if (typeof XMLHttpRequest === 'undefined') return dofetch(method, url, body, cb)
 	var request = new XMLHttpRequest()
-	request.onreadystatechange = function (e) {
+	request.onreadystatechange = function(e) {
 		if (request.readyState !== 4) return
 		cb && cb(request.responseText, request.status)
 		cb = undefined // dont call cb anymore
 	}
 
-	request.onerror = function () {
+	request.onerror = function() {
 		cb && cb(request.responseText, -1) // network error
 		cb = undefined // dont call cb anymore
 	}
@@ -227,13 +239,13 @@ function xhrsend (method, url, body, cb) {
 
 // JSON.parse without exeption
 // return undefined when parsing invalid JSON string
-function parseJSON (str) {
+function parseJSON(str) {
 	try {
 		return JSON.parse(str)
 	} catch (e) {}
 }
 
-function Pubsub () {
+function Pubsub() {
 	// holds all subscriptions for all topics
 	// example {
 	//   topic1: [cb1, cb2],
@@ -243,7 +255,7 @@ function Pubsub () {
 
 	// emit notifies any callback functions that previously
 	// subscribed to the topic (by the on function)
-	this.emit = function (topic) {
+	this.emit = function(topic) {
 		// skip the first item in arguments, which is the topic
 		var args = []
 		for (var i = 1; i < arguments.length; i++) args.push(arguments[i])
@@ -256,7 +268,7 @@ function Pubsub () {
 	// register a callback function for a topic
 	// when something is sent to the topic (by the emit function),
 	// the callback function will be called
-	this.on = function (topic, cb) {
+	this.on = function(topic, cb) {
 		if (!listeners[topic]) listeners[topic] = []
 		listeners[topic].push(cb)
 	}
@@ -266,7 +278,7 @@ function Pubsub () {
 // before sending a next request
 // the results is determind based on exponential backoff algorithm
 // see https://en.wikipedia.org/wiki/Exponential_backoff
-function calcNextBackoff (attempts) {
+function calcNextBackoff(attempts) {
 	var RECONNECT_INTERVAL = 1000
 	var MAX_RECONNECT_INTERVAL = 10000
 	var RECONNECT_DECAY = 1.5
@@ -278,19 +290,19 @@ function calcNextBackoff (attempts) {
 
 // retryable decides whether we should resent the HTTP request
 // based on last response or network state
-function retryable (code) {
+function retryable(code) {
 	// code = 0 means server return response without CORS header, so we are unable to read it
 	// code = -1 means the network connection is dead
 	return (code >= 500 && code < 600) || code === 0 || code === -1 || code === 429
 }
 
-function repeat (ele, n) {
+function repeat(ele, n) {
 	var arr = []
 	for (var i = 0; i < n; i++) arr.push(ele)
 	return arr
 }
 
-function absUrl (url) {
+function absUrl(url) {
 	url = url || ''
 	if (url.startsWith('//')) return 'https:' + url
 	return url

package/realtime.test.js

@@ -1,8 +1,7 @@
 var test = require('tape')
-const axios = require('axios')
 var Realtime = require('./realtime.js')
 
-function makeMockServer (script) {
+function makeMockServer(script) {
 	var i = -1
 	return (method, url, body, cb) => {
 		i++
@@ -10,32 +9,7 @@ function makeMockServer (script) {
 	}
 }
 
-function axiosCall (method, url, body, cb) {
-	method = method.toLowerCase()
-	return axios[method](url, body).then(resp => cb(resp.rawData, resp.statusCode))
-}
-
-test.skip('realtime simple', async t => {
-	// var accid = 'acqcsmrppbftadjzxnvo'
-	var userid = 'usqnkpwrkrszjgyfajemn'
-	var mask = 'acqcsmrppbftadjzxnvo@usqnkpwrkrszjgyfajemn@Iqz40aZ4dwQuvFn8kJA6gqKnyyQLFA0xU44Emw=='
-
-	var realtime = new Realtime({ user_mask: mask }, axiosCall)
-	var evid = '-'
-	realtime.onEvent(ev => {
-		if (ev.data.message.id === evid) {
-			realtime.stop()
-			t.end()
-		}
-	})
-	realtime.onInterrupted(() => {})
-	var err = await realtime.subscribe(['message_pong.account.acqcsmrppbftadjzxnvo.user.usqnkpwrkrszjgyfajemn'])
-	t.equal(err, undefined)
-	var res = await sendMsg(userid, mask)
-	evid = res.data.id
-})
-
-test('realtime', async t => {
+test('realtime', async (t) => {
 	var callapi = makeMockServer([
 		async (method, url, body, cb) => {
 			// must first call sub and must attach user-mask in the query
@@ -58,16 +32,15 @@ test('realtime', async t => {
 			t.true(url.indexOf('token=token1') !== -1)
 			realtime.stop()
 			cb(`{"events": [], "token": "-"}`, 200)
-			t.end()
 		},
 	])
 
-	var realtime = new Realtime('', { user_mask: 'mask123' }, callapi)
+	var realtime = new Realtime('', {user_mask: 'mask123'}, callapi)
 	var err = await realtime.subscribe(['message_pong'])
-	t.equal(err, undefined)
+	t.true(Object.keys(err).length === 0)
 })
 
-test('realtime subs when server down and then backup', async t => {
+test('realtime subs when server down and then backup', async (t) => {
 	var callapi = makeMockServer([
 		async (method, url, body, cb) => {
 			// must first call sub and must attach user-mask in the query
@@ -96,16 +69,15 @@ test('realtime subs when server down and then backup', async t => {
 			t.true(url.indexOf('token=token0') !== -1)
 			realtime.stop()
 			cb(`{"events": [], "token": "-"}`, 200)
-			t.end()
 		},
 	])
 
-	var realtime = new Realtime('', { user_mask: 'mask123' }, callapi)
+	var realtime = new Realtime('', {user_mask: 'mask123'}, callapi)
 	var err = await realtime.subscribe(['message_pong'])
-	t.equal(err, undefined)
+	t.true(Object.keys(err).length === 0)
 })
 
-test('realtime must stop if there is something wrong with our credential or our code', async t => {
+test('realtime must stop if there is something wrong with our credential or our code', async (t) => {
 	var subcode
 	var callapi = makeMockServer([
 		async (method, url, bkody, cb) => {
@@ -115,27 +87,13 @@ test('realtime must stop if there is something wrong with our credential or our
 			t.true(url.indexOf('user-mask=mask123') !== -1)
 			cb(`400 invalid mask`, 400)
 			realtime.stop()
-			t.end()
 		},
 	])
 
-	var realtime = new Realtime('', { user_mask: 'mask123' }, callapi)
+	var realtime = new Realtime('', {user_mask: 'mask123'}, callapi)
 	realtime.onInterrupted((_, _1, code) => {
 		subcode = code
 	})
 	var err = await realtime.subscribe(['message_pong'])
-	t.false(err === undefined)
+	t.false(Object.keys(err).length === 0)
 })
-
-function sendMsg (userid, mask, text) {
-	if (!text) text = 'hello'
-	var ev = {
-		by: { id: userid, type: 'user' },
-		data: { message: { text, format: 'plaintext' } },
-		type: 'message_sent',
-	}
-
-	mask = encodeURIComponent(mask)
-	var convoid = 'csqohilsfssnkrhnli'
-	return axios.post(`https://api.subiz.net/4.0/conversations/${convoid}/messages?x-user-mask=${mask}`, ev)
-}

package/.eslintrc.js

@@ -1,197 +0,0 @@
-module.exports = {
-	parserOptions: {
-		ecmaVersion: 2018,
-		ecmaFeatures: {
-			jsx: true,
-		},
-		sourceType: 'module',
-	},
-	extends: 'eslint:recommended',
-	env: {
-		es6: true,
-		node: true,
-	},
-	globals: {
-		document: false,
-		navigator: false,
-		window: false,
-		test: false,
-		xtest: false,
-		expect: false,
-		import: false,
-		require: false,
-	},
-	rules: {
-		'accessor-pairs': 'error',
-		'arrow-spacing': ['error', {before: true, after: true}],
-		'block-spacing': ['error', 'always'],
-		'brace-style': ['error', '1tbs', {allowSingleLine: true}],
-		'comma-dangle': ['error', 'always-multiline'],
-		'comma-spacing': ['error', {before: false, after: true}],
-		'comma-style': ['error', 'last'],
-		'constructor-super': 'error',
-		curly: ['error', 'multi-line'],
-		'dot-location': ['error', 'object'],
-		'eol-last': 'error',
-		eqeqeq: ['error', 'always', {null: 'ignore'}],
-		'func-call-spacing': ['error', 'never'],
-		'generator-star-spacing': ['error', {before: true, after: true}],
-		'handle-callback-err': ['error', '^(err|error)$'],
-		indent: ['error', 'tab'],
-		'key-spacing': ['error', {beforeColon: false, afterColon: true}],
-		'keyword-spacing': ['error', {before: true, after: true}],
-		'new-cap': ['error', {newIsCap: true, capIsNew: false}],
-		'new-parens': 'error',
-		'no-array-constructor': 'error',
-		'no-caller': 'error',
-		'no-class-assign': 'error',
-		'no-compare-neg-zero': 'error',
-		'no-cond-assign': 'error',
-		'no-const-assign': 'error',
-		'no-constant-condition': ['error', {checkLoops: false}],
-		'no-control-regex': 'error',
-		'no-debugger': 'error',
-		'no-delete-var': 'error',
-		'no-dupe-args': 'error',
-		'no-dupe-class-members': 'error',
-		'no-dupe-keys': 'error',
-		'no-duplicate-case': 'error',
-		'no-empty-character-class': 'error',
-		'no-empty-pattern': 'error',
-		'no-eval': 'error',
-		'no-ex-assign': 'error',
-		'no-extend-native': 'error',
-		'no-extra-bind': 'error',
-		'no-extra-boolean-cast': 'error',
-		'no-extra-parens': ['error', 'functions'],
-		'no-fallthrough': 'error',
-		'no-floating-decimal': 'error',
-		'no-func-assign': 'error',
-		'no-global-assign': 'error',
-		'no-implied-eval': 'error',
-		'no-inner-declarations': ['error', 'functions'],
-		'no-invalid-regexp': 'error',
-		'no-irregular-whitespace': 'error',
-		'no-iterator': 'error',
-		'no-label-var': 'error',
-		'no-labels': ['error', {allowLoop: false, allowSwitch: false}],
-		'no-lone-blocks': 'error',
-		'no-mixed-operators': [
-			'error',
-			{
-				groups: [
-					['==', '!=', '===', '!==', '>', '>=', '<', '<='],
-					['&&', '||'],
-					['in', 'instanceof'],
-				],
-				allowSamePrecedence: true,
-			},
-		],
-		'no-mixed-spaces-and-tabs': 'error',
-		'no-multi-spaces': 'error',
-		'no-multi-str': 'error',
-		'no-multiple-empty-lines': ['error', {max: 1, maxEOF: 0}],
-		'no-negated-in-lhs': 'error',
-		'no-new': 'error',
-		'no-new-func': 'error',
-		'no-new-object': 'error',
-		'no-new-require': 'error',
-		'no-new-symbol': 'error',
-		'no-new-wrappers': 'error',
-		'no-obj-calls': 'error',
-		'no-octal': 'error',
-		'no-octal-escape': 'error',
-		'no-path-concat': 'error',
-		'no-proto': 'error',
-		'no-redeclare': 'error',
-		'no-regex-spaces': 'error',
-		'no-return-assign': ['error', 'except-parens'],
-		'no-return-await': 'error',
-		'no-self-assign': 'error',
-		'no-self-compare': 'error',
-		'no-sequences': 'error',
-		'no-shadow-restricted-names': 'error',
-		'no-sparse-arrays': 'error',
-		'no-template-curly-in-string': 'error',
-		'no-this-before-super': 'error',
-		'no-throw-literal': 'error',
-		'no-trailing-spaces': 'error',
-		'no-undef': 'error',
-		'no-undef-init': 'error',
-		'no-unexpected-multiline': 'error',
-		'no-unmodified-loop-condition': 'error',
-		'no-unneeded-ternary': ['error', {defaultAssignment: false}],
-		'no-unreachable': 'error',
-		'no-unsafe-finally': 'error',
-		'no-unsafe-negation': 'error',
-		'no-unused-expressions': [
-			'error',
-			{
-				allowShortCircuit: true,
-				allowTernary: true,
-				allowTaggedTemplates: true,
-			},
-		],
-		'no-unused-vars': [
-			'error',
-			{
-				vars: 'all',
-				args: 'none',
-				ignoreRestSiblings: true,
-				varsIgnorePattern: '^_',
-			},
-		],
-		'no-use-before-define': [
-			'error',
-			{functions: false, classes: false, variables: false},
-		],
-		'no-useless-call': 'error',
-		'no-useless-computed-key': 'error',
-		'no-useless-constructor': 'error',
-		'no-useless-escape': 'error',
-		'no-useless-rename': 'error',
-		'no-useless-return': 'error',
-		'no-whitespace-before-property': 'error',
-		'no-with': 'error',
-		'object-curly-spacing': ['error', 'always'],
-		'object-property-newline': [
-			'error',
-			{allowMultiplePropertiesPerLine: true},
-		],
-		'one-var': ['error', {initialized: 'never'}],
-		'operator-linebreak': [
-			'error',
-			'after',
-			{overrides: {'?': 'before', ':': 'before'}},
-		],
-		'padded-blocks': [
-			'error',
-			{blocks: 'never', switches: 'never', classes: 'never'},
-		],
-		'prefer-promise-reject-errors': 'error',
-		quotes: [
-			'error',
-			'single',
-			{avoidEscape: true, allowTemplateLiterals: true},
-		],
-		'rest-spread-spacing': ['error', 'never'],
-		semi: ['error', 'never'],
-		'semi-spacing': ['error', {before: false, after: true}],
-		'space-before-blocks': ['error', 'always'],
-		'space-before-function-paren': ['error', 'always'],
-		'space-in-parens': ['error', 'never'],
-		'space-infix-ops': 'error',
-		'space-unary-ops': ['error', {words: true, nonwords: false}],
-		'symbol-description': 'error',
-		'template-curly-spacing': ['error', 'never'],
-		'template-tag-spacing': ['error', 'never'],
-		'unicode-bom': ['error', 'never'],
-		'use-isnan': 'error',
-		'valid-typeof': ['error', {requireStringLiterals: true}],
-		'wrap-iife': ['error', 'any', {functionPrototypeMethods: true}],
-		'yield-star-spacing': ['error', 'both'],
-		yoda: ['error', 'never'],
-		'max-depth': ['error', {max: 5}],
-		'max-len': 'off',
-	},
-}

package/test/client_test.js

@@ -1,161 +0,0 @@
-var WebSocket = require('ws')
-var client = require('../src/client.js')
-client.env.WebSocket = WebSocket
-
-const server = require('./test_server.js').server
-var host = 'ws://localhost:8088'
-function testServerDown2 (done) {
-	var r = Math.random()
-	var ws = new client.WS({ pickUrl: done => done(`${host}/3/${r}`) })
-
-	var connid = ''
-	var fistconnect = true
-	var connected = 0
-	ws.onopen = (a, id) => {
-		connected++
-		connid = id
-	}
-
-	var mescount = 0
-	ws.onmessage = (a, mes) => {
-		mescount++
-		if (mescount == 1) {
-			if (connected != 1) {
-				throw 'invalid connection id'
-			}
-
-			if (mes != 1) {
-				throw `invalid first message, got ${mes}`
-			}
-			return
-		}
-		if (mescount == 2) {
-			if (connid != 4) throw 'wrong connid'
-			if (connected != 2) throw `wrong connected time, got ${connected}`
-			if (closed != 3) throw `wrong closed time, got ${closed}`
-			if (errcount != 0) throw `wrong err count, got ${errcount}`
-			if (mes != 2) throw `invalid first message, got ${mes}`
-			done()
-		}
-	}
-
-	var closed = 0
-	ws.onclose = () => {
-		closed++
-		if (closed == 1) {
-			if (connected != 1) {
-				throw 'invalid state'
-			}
-		}
-	}
-
-	var errcount = 0
-	ws.onerror = (a, err) => {
-		errcount++
-	}
-}
-
-function testServerDown (done) {
-	var r = Math.random()
-	var ws = new client.WS({ pickUrl: done => done(`${host}/2/${r}`) })
-
-	var connid = ''
-	var fistconnect = true
-	var connected = 0
-	ws.onopen = (a, id) => {
-		connected++
-		connid = id
-	}
-
-	var mescount = 0
-	ws.onmessage = (a, mes) => {
-		mescount++
-		if (mescount == 1) {
-			if (connected != 1) {
-				throw 'invalid connection id'
-			}
-
-			if (mes != 1) {
-				throw `invalid first message, got ${mes}`
-			}
-			return
-		}
-		if (mescount == 2) {
-			if (connid != 5) throw `wrong connid, got ${connid}`
-			if (connected != 2) throw `wrong connected time, got ${connected}`
-			if (closed != 4) throw `wrong closed time, got ${closed}`
-			if (errcount != 1) throw `wrong err count, got ${errcount}`
-			if (mes != 2) throw `invalid first message, got ${mes}`
-			done()
-		}
-	}
-
-	var closed = 0
-	ws.onclose = () => {
-		closed++
-		if (closed == 1) {
-			if (connected != 1) {
-				throw 'invalid state'
-			}
-		}
-	}
-
-	var errcount = 0
-	ws.onerror = (a, err) => {
-		errcount++
-		if (errcount == 1) {
-			if (err != 'dead') {
-				throw `invalid error message ${JSON.stringify(err)}`
-			}
-		}
-	}
-}
-
-function testNormal (done) {
-	var ws = new client.WS({ pickUrl: done => done(`${host}/1`) })
-	var connid = ''
-	ws.onopen = (a, id) => {
-		console.log("a")
-		connid = id
-	}
-
-	var first = true
-
-	ws.onmessage = (a, mes) => {
-		if (first) {
-			first = false
-			if (connid == '') {
-				throw 'invalid connection id'
-			}
-
-			if (mes != 1) {
-				throw `invalid first message, got ${mes}`
-			}
-			return
-		}
-
-		if (mes != 2) {
-			throw `invalid second message, got ${mes}`
-		}
-		done()
-	}
-	console.log("b")
-}
-
-function main () {
-	server.listen(8088, () => {
-		var done = 0
-		function donecheck () {
-			done++
-			if (done === 3) {
-				console.log('PASS')
-				process.exit(0)
-			}
-		}
-		testServerDown(donecheck)
-		testServerDown2(donecheck)
-		testNormal(donecheck)
-	})
-}
-
-main()

package/test/test_server.js

@@ -1,140 +0,0 @@
-const http = require('http')
-const WebSocket = require('ws')
-const url = require('url')
-const querystring = require('querystring')
-
-const server = http.createServer()
-const wss1 = new WebSocket.Server({ noServer: true })
-const wss2 = new WebSocket.Server({ noServer: true })
-const wss3 = new WebSocket.Server({ noServer: true })
-
-let counter = {}
-
-function getID (path) {
-	const pathname = url.parse(path).pathname
-	return pathname.split('/')
-}
-
-wss1.on('connection', ws => {
-	ws.send(
-		`{"type": "init", "offset": 0, "data": ${JSON.stringify(
-			JSON.stringify({ id: 'aaa' })
-		)}}`
-	)
-	ws.send(`{"offset": 1, "data":"1"}`)
-	ws.send(`{"offset": 2, "data":"2"}`)
-})
-
-wss2.on('connection', (ws, request) => {
-	let [x, no, id] = getID(request.url)
-
-	if (!counter[id]) counter[id] = 0
-	counter[id]++
-
-	//console.log(`[${id}] new connection`, counter[id])
-
-	let qs = request.url.split('?')[1] || ''
-	const params = querystring.parse(qs)
-
-	//console.log('params', params)
-
-	if (counter[id] == 1) {
-		ws.send(
-			`{"type": "init", "offset": 0, "data": ${JSON.stringify(
-				JSON.stringify({ id: counter[id] })
-			)}}`
-		)
-		ws.send(`{"offset": 1, "data":"1"}`)
-		ws.terminate()
-		return
-	}
-
-	if (counter[id] < 4) {
-		if (!params.connection_id) {
-			throw new Error('connection_id not found')
-		}
-
-		ws.terminate()
-		return
-	}
-
-	if (counter[id] === 4) {
-		// console.log("server", "dead")
-		ws.send(`{"error": "dead"}`)
-		return
-	}
-
-	if (counter[id] === 5) {
-		// console.log("server", "heaer")
-		if (Object.keys(params).length > 0) {
-			throw new Error('query string is not empty')
-		}
-
-		ws.send(
-			`{"type": "init", "offset": 0, "data": ${JSON.stringify(
-				JSON.stringify({ id: counter[id] })
-			)}}`
-		)
-		ws.send(`{"offset": 1, "data":"2"}`)
-	}
-})
-
-wss3.on('connection', (ws, request) => {
-	let [x, no, id] = getID(request.url)
-
-	if (!counter[id]) counter[id] = 0
-	counter[id]++
-
-	// console.log(`[${id}] new connection`, counter[id])
-
-	if (counter[id] == 1) {
-		ws.send(
-			`{"type": "init", "offset": 0, "data": ${JSON.stringify(
-				JSON.stringify({ id: counter[id] })
-			)}}`
-		)
-		ws.send(`{"offset": 1, "data":"1"}`)
-		ws.terminate()
-		return
-	}
-
-	if (counter[id] < 4) {
-		ws.terminate()
-		return
-	}
-
-	if (counter[id] === 4) {
-		ws.send(
-			`{"type": "init", "offset": 0, "data": ${JSON.stringify(
-				JSON.stringify({ id: counter[id] })
-			)}}`
-		)
-		ws.send(`{"offset": 1, "data":"2"}`)
-	}
-})
-
-server.on('upgrade', (request, socket, head) => {
-	let [x, no, id] = getID(request.url)
-
-	switch (no) {
-	case '1':
-		wss1.handleUpgrade(request, socket, head, ws => {
-			wss1.emit('connection', ws, request)
-		})
-		break
-	case '2':
-		wss2.handleUpgrade(request, socket, head, ws => {
-			wss2.emit('connection', ws, request)
-		})
-		break
-	case '3':
-		wss3.handleUpgrade(request, socket, head, ws => {
-			wss3.emit('connection', ws, request)
-		})
-		break
-	default:
-		socket.destroy()
-	}
-})
-
-exports.server = server