1095 lines
27 KiB
JavaScript
1095 lines
27 KiB
JavaScript
// Licensed to Elasticsearch B.V under one or more agreements.
|
|
// Elasticsearch B.V licenses this file to you under the Apache 2.0 License.
|
|
// See the LICENSE file in the project root for more information
|
|
|
|
'use strict'
|
|
|
|
const { test } = require('tap')
|
|
const { URL } = require('url')
|
|
const { Client, ConnectionPool, Transport } = require('../../index')
|
|
const { CloudConnectionPool } = require('../../lib/pool')
|
|
const { buildServer } = require('../utils')
|
|
|
|
test('Configure host', t => {
|
|
t.test('Single string', t => {
|
|
const client = new Client({
|
|
node: 'http://localhost:9200'
|
|
})
|
|
const pool = client.connectionPool
|
|
t.match(pool.connections.find(c => c.id === 'http://localhost:9200/'), {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'http://localhost:9200/',
|
|
ssl: null,
|
|
deadCount: 0,
|
|
resurrectTimeout: 0,
|
|
roles: {
|
|
master: true,
|
|
data: true,
|
|
ingest: true,
|
|
ml: false
|
|
}
|
|
})
|
|
t.end()
|
|
})
|
|
|
|
t.test('Array of strings', t => {
|
|
const client = new Client({
|
|
nodes: ['http://localhost:9200', 'http://localhost:9201']
|
|
})
|
|
const pool = client.connectionPool
|
|
t.match(pool.connections.find(c => c.id === 'http://localhost:9200/'), {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'http://localhost:9200/',
|
|
ssl: null,
|
|
deadCount: 0,
|
|
resurrectTimeout: 0,
|
|
roles: {
|
|
master: true,
|
|
data: true,
|
|
ingest: true,
|
|
ml: false
|
|
}
|
|
})
|
|
t.match(pool.connections.find(c => c.id === 'http://localhost:9201/'), {
|
|
url: new URL('http://localhost:9201'),
|
|
id: 'http://localhost:9201/',
|
|
ssl: null,
|
|
deadCount: 0,
|
|
resurrectTimeout: 0,
|
|
roles: {
|
|
master: true,
|
|
data: true,
|
|
ingest: true,
|
|
ml: false
|
|
}
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
t.test('Single object', t => {
|
|
const client = new Client({
|
|
node: {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'node',
|
|
roles: {
|
|
master: true,
|
|
data: false,
|
|
ingest: false
|
|
},
|
|
ssl: 'ssl'
|
|
}
|
|
})
|
|
const pool = client.connectionPool
|
|
t.match(pool.connections.find(c => c.id === 'node'), {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'node',
|
|
ssl: 'ssl',
|
|
deadCount: 0,
|
|
resurrectTimeout: 0
|
|
})
|
|
|
|
t.deepEqual(pool.connections.find(c => c.id === 'node').roles, {
|
|
master: true,
|
|
data: false,
|
|
ingest: false,
|
|
ml: false
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
t.test('Array of objects', t => {
|
|
const client = new Client({
|
|
nodes: [{
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'node1',
|
|
roles: {
|
|
master: true,
|
|
data: false,
|
|
ingest: false
|
|
},
|
|
ssl: 'ssl'
|
|
}, {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'node2',
|
|
roles: {
|
|
master: false,
|
|
data: true,
|
|
ingest: false
|
|
},
|
|
ssl: 'ssl'
|
|
}]
|
|
})
|
|
const pool = client.connectionPool
|
|
t.match(pool.connections.find(c => c.id === 'node1'), {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'node1',
|
|
ssl: 'ssl',
|
|
deadCount: 0,
|
|
resurrectTimeout: 0
|
|
})
|
|
|
|
t.deepEqual(pool.connections.find(c => c.id === 'node1').roles, {
|
|
master: true,
|
|
data: false,
|
|
ingest: false,
|
|
ml: false
|
|
})
|
|
|
|
t.match(pool.connections.find(c => c.id === 'node2'), {
|
|
url: new URL('http://localhost:9200'),
|
|
id: 'node2',
|
|
ssl: 'ssl',
|
|
deadCount: 0,
|
|
resurrectTimeout: 0
|
|
})
|
|
|
|
t.deepEqual(pool.connections.find(c => c.id === 'node2').roles, {
|
|
master: false,
|
|
data: true,
|
|
ingest: false,
|
|
ml: false
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
t.test('Custom headers', t => {
|
|
const client = new Client({
|
|
node: {
|
|
url: new URL('http://localhost:9200'),
|
|
headers: { 'x-foo': 'bar' },
|
|
id: 'node'
|
|
}
|
|
})
|
|
const pool = client.connectionPool
|
|
t.match(pool.connections.find(c => c.id === 'node'), {
|
|
url: new URL('http://localhost:9200'),
|
|
headers: { 'x-foo': 'bar' }
|
|
})
|
|
t.end()
|
|
})
|
|
|
|
t.test('Missing node conf', t => {
|
|
try {
|
|
new Client() // eslint-disable-line
|
|
t.fail('Should fail')
|
|
} catch (err) {
|
|
t.ok(err)
|
|
}
|
|
t.end()
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
test('Authentication', t => {
|
|
t.test('Basic', t => {
|
|
t.test('Node with basic auth data in the url', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'Basic Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://foo:bar@localhost:${port}`
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Node with basic auth data in the url (array of nodes)', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'Basic Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
nodes: [`http://foo:bar@localhost:${port}`]
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Node with basic auth data in the options', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'Basic Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
username: 'foo',
|
|
password: 'bar'
|
|
}
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Custom basic authentication per request', t => {
|
|
t.plan(6)
|
|
|
|
var first = true
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: first ? 'hello' : 'Basic Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://foo:bar@localhost:${port}`
|
|
})
|
|
|
|
client.info({}, {
|
|
headers: {
|
|
authorization: 'hello'
|
|
}
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
first = false
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Override default basic authentication per request', t => {
|
|
t.plan(6)
|
|
|
|
var first = true
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: first ? 'hello' : 'Basic Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
username: 'foo',
|
|
password: 'bar'
|
|
}
|
|
})
|
|
|
|
client.info({}, {
|
|
headers: {
|
|
authorization: 'hello'
|
|
}
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
first = false
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
t.test('ApiKey', t => {
|
|
t.test('Node with ApiKey auth data in the options as string', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'ApiKey Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
apiKey: 'Zm9vOmJhcg=='
|
|
}
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Node with ApiKey auth data in the options as object', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'ApiKey Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
apiKey: { id: 'foo', api_key: 'bar' }
|
|
}
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Custom ApiKey authentication per request', t => {
|
|
t.plan(6)
|
|
|
|
var first = true
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: first ? 'ApiKey Zm9vOmJhcg==' : 'Basic Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://foo:bar@localhost:${port}`
|
|
})
|
|
|
|
client.info({}, {
|
|
headers: {
|
|
authorization: 'ApiKey Zm9vOmJhcg=='
|
|
}
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
first = false
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('Override default ApiKey authentication per request', t => {
|
|
t.plan(6)
|
|
|
|
var first = true
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: first ? 'hello' : 'ApiKey Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
apiKey: 'Zm9vOmJhcg=='
|
|
}
|
|
})
|
|
|
|
client.info({}, {
|
|
headers: {
|
|
authorization: 'hello'
|
|
}
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
first = false
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('ApiKey should take precedence over basic auth (in url)', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'ApiKey Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://user:pwd@localhost:${port}`,
|
|
auth: {
|
|
apiKey: 'Zm9vOmJhcg=='
|
|
}
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('ApiKey should take precedence over basic auth (in opts)', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
authorization: 'ApiKey Zm9vOmJhcg=='
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
apiKey: 'Zm9vOmJhcg==',
|
|
username: 'user',
|
|
password: 'pwd'
|
|
}
|
|
})
|
|
|
|
client.info((err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
test('Custom headers per request', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.match(req.headers, {
|
|
'x-foo': 'bar',
|
|
'x-baz': 'faz'
|
|
})
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://foo:bar@localhost:${port}`
|
|
})
|
|
|
|
client.info({}, {
|
|
headers: {
|
|
'x-foo': 'bar',
|
|
'x-baz': 'faz'
|
|
}
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
test('Client close', t => {
|
|
t.plan(2)
|
|
|
|
class MyConnectionPool extends ConnectionPool {
|
|
empty (callback) {
|
|
t.ok('called')
|
|
super.empty(callback)
|
|
}
|
|
}
|
|
|
|
const client = new Client({
|
|
node: 'http://localhost:9200',
|
|
ConnectionPool: MyConnectionPool
|
|
})
|
|
|
|
client.close(() => t.pass('Closed'))
|
|
})
|
|
|
|
test('Client close (promise)', t => {
|
|
t.plan(2)
|
|
|
|
class MyConnectionPool extends ConnectionPool {
|
|
empty (callback) {
|
|
t.ok('called')
|
|
super.empty(callback)
|
|
}
|
|
}
|
|
|
|
const client = new Client({
|
|
node: 'http://localhost:9200',
|
|
ConnectionPool: MyConnectionPool
|
|
})
|
|
|
|
client.close()
|
|
.then(() => t.pass('Closed'))
|
|
})
|
|
|
|
test('Extend client APIs', t => {
|
|
t.test('Extend a single method', t => {
|
|
t.plan(5)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
client.extend('method', ({ makeRequest, result, ConfigurationError }) => {
|
|
t.type(makeRequest, 'function')
|
|
t.true(new ConfigurationError() instanceof Error)
|
|
t.deepEqual(result, {
|
|
body: null,
|
|
statusCode: null,
|
|
headers: null,
|
|
warnings: null
|
|
})
|
|
|
|
return (params, options) => {
|
|
t.deepEqual(params, { you_know: 'for search' })
|
|
t.deepEqual(options, { winter: 'is coming' })
|
|
}
|
|
})
|
|
|
|
client.method(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' }
|
|
)
|
|
})
|
|
|
|
t.test('Create a namespace and a method', t => {
|
|
t.plan(5)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
client.extend('namespace.method', ({ makeRequest, result, ConfigurationError }) => {
|
|
t.type(makeRequest, 'function')
|
|
t.true(new ConfigurationError() instanceof Error)
|
|
t.deepEqual(result, {
|
|
body: null,
|
|
statusCode: null,
|
|
headers: null,
|
|
warnings: null
|
|
})
|
|
|
|
return (params, options) => {
|
|
t.deepEqual(params, { you_know: 'for search' })
|
|
t.deepEqual(options, { winter: 'is coming' })
|
|
}
|
|
})
|
|
|
|
client.namespace.method(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' }
|
|
)
|
|
})
|
|
|
|
t.test('Create a namespace and multiple methods', t => {
|
|
t.plan(10)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
client.extend('namespace.method1', ({ makeRequest, result, ConfigurationError }) => {
|
|
t.type(makeRequest, 'function')
|
|
t.true(new ConfigurationError() instanceof Error)
|
|
t.deepEqual(result, {
|
|
body: null,
|
|
statusCode: null,
|
|
headers: null,
|
|
warnings: null
|
|
})
|
|
|
|
return (params, options) => {
|
|
t.deepEqual(params, { you_know: 'for search' })
|
|
t.deepEqual(options, { winter: 'is coming' })
|
|
}
|
|
})
|
|
|
|
client.extend('namespace.method2', ({ makeRequest, result, ConfigurationError }) => {
|
|
t.type(makeRequest, 'function')
|
|
t.true(new ConfigurationError() instanceof Error)
|
|
t.deepEqual(result, {
|
|
body: null,
|
|
statusCode: null,
|
|
headers: null,
|
|
warnings: null
|
|
})
|
|
|
|
return (params, options) => {
|
|
t.deepEqual(params, { you_know: 'for search' })
|
|
t.deepEqual(options, { winter: 'is coming' })
|
|
}
|
|
})
|
|
|
|
client.namespace.method1(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' }
|
|
)
|
|
|
|
client.namespace.method2(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' }
|
|
)
|
|
})
|
|
|
|
t.test('Cannot override an existing method', t => {
|
|
t.plan(1)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
try {
|
|
client.extend('index', () => {})
|
|
t.fail('Should throw')
|
|
} catch (err) {
|
|
t.is(err.message, 'The method "index" already exists')
|
|
}
|
|
})
|
|
|
|
t.test('Cannot override an existing namespace and method', t => {
|
|
t.plan(1)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
try {
|
|
client.extend('indices.delete', () => {})
|
|
t.fail('Should throw')
|
|
} catch (err) {
|
|
t.is(err.message, 'The method "delete" already exists on namespace "indices"')
|
|
}
|
|
})
|
|
|
|
t.test('Can override an existing method with { force: true }', t => {
|
|
t.plan(1)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
try {
|
|
client.extend('index', { force: true }, () => t.pass('Called'))
|
|
} catch (err) {
|
|
t.fail('Should not throw')
|
|
}
|
|
})
|
|
|
|
t.test('Can override an existing namespace and method with { force: true }', t => {
|
|
t.plan(1)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
try {
|
|
client.extend('indices.delete', { force: true }, () => t.pass('Called'))
|
|
} catch (err) {
|
|
t.fail('Should not throw')
|
|
}
|
|
})
|
|
|
|
t.test('Should call the transport.request method', t => {
|
|
t.plan(2)
|
|
|
|
class MyTransport extends Transport {
|
|
request (params, options) {
|
|
t.deepEqual(params, { you_know: 'for search' })
|
|
t.deepEqual(options, { winter: 'is coming' })
|
|
}
|
|
}
|
|
|
|
const client = new Client({
|
|
node: 'http://localhost:9200',
|
|
Transport: MyTransport
|
|
})
|
|
client.extend('method', ({ makeRequest, result, ConfigurationError }) => {
|
|
return (params, options) => makeRequest(params, options)
|
|
})
|
|
|
|
client.method(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' }
|
|
)
|
|
})
|
|
|
|
t.test('Should support callbacks', t => {
|
|
t.plan(2)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
client.extend('method', ({ makeRequest, result, ConfigurationError }) => {
|
|
return (params, options, callback) => {
|
|
callback(null, { hello: 'world' })
|
|
}
|
|
})
|
|
|
|
client.method(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' },
|
|
(err, res) => {
|
|
t.error(err)
|
|
t.deepEqual(res, { hello: 'world' })
|
|
}
|
|
)
|
|
})
|
|
|
|
t.test('Should support promises', t => {
|
|
t.plan(1)
|
|
|
|
const client = new Client({ node: 'http://localhost:9200' })
|
|
client.extend('method', ({ makeRequest, result, ConfigurationError }) => {
|
|
return (params, options) => {
|
|
return new Promise((resolve, reject) => {
|
|
resolve({ hello: 'world' })
|
|
})
|
|
}
|
|
})
|
|
|
|
client
|
|
.method(
|
|
{ you_know: 'for search' },
|
|
{ winter: 'is coming' }
|
|
)
|
|
.then(res => t.deepEqual(res, { hello: 'world' }))
|
|
.catch(err => t.fail(err))
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
test('Elastic cloud config', t => {
|
|
t.test('Basic', t => {
|
|
t.plan(5)
|
|
const client = new Client({
|
|
cloud: {
|
|
// 'localhost$abcd$efgh'
|
|
id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==',
|
|
username: 'elastic',
|
|
password: 'changeme'
|
|
}
|
|
})
|
|
|
|
const pool = client.connectionPool
|
|
t.ok(pool instanceof CloudConnectionPool)
|
|
t.match(pool.connections.find(c => c.id === 'https://abcd.localhost/'), {
|
|
url: new URL('https://elastic:changeme@abcd.localhost'),
|
|
id: 'https://abcd.localhost/',
|
|
headers: {
|
|
authorization: 'Basic ' + Buffer.from('elastic:changeme').toString('base64')
|
|
},
|
|
ssl: { secureProtocol: 'TLSv1_2_method' },
|
|
deadCount: 0,
|
|
resurrectTimeout: 0,
|
|
roles: {
|
|
master: true,
|
|
data: true,
|
|
ingest: true,
|
|
ml: false
|
|
}
|
|
})
|
|
|
|
t.strictEqual(client.transport.compression, 'gzip')
|
|
t.strictEqual(client.transport.suggestCompression, true)
|
|
t.deepEqual(pool._ssl, { secureProtocol: 'TLSv1_2_method' })
|
|
})
|
|
|
|
t.test('Auth as separate option', t => {
|
|
t.plan(5)
|
|
const client = new Client({
|
|
cloud: {
|
|
// 'localhost$abcd$efgh'
|
|
id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA=='
|
|
},
|
|
auth: {
|
|
username: 'elastic',
|
|
password: 'changeme'
|
|
}
|
|
})
|
|
|
|
const pool = client.connectionPool
|
|
t.ok(pool instanceof CloudConnectionPool)
|
|
t.match(pool.connections.find(c => c.id === 'https://abcd.localhost/'), {
|
|
url: new URL('https://elastic:changeme@abcd.localhost'),
|
|
id: 'https://abcd.localhost/',
|
|
headers: {
|
|
authorization: 'Basic ' + Buffer.from('elastic:changeme').toString('base64')
|
|
},
|
|
ssl: { secureProtocol: 'TLSv1_2_method' },
|
|
deadCount: 0,
|
|
resurrectTimeout: 0,
|
|
roles: {
|
|
master: true,
|
|
data: true,
|
|
ingest: true,
|
|
ml: false
|
|
}
|
|
})
|
|
|
|
t.strictEqual(client.transport.compression, 'gzip')
|
|
t.strictEqual(client.transport.suggestCompression, true)
|
|
t.deepEqual(pool._ssl, { secureProtocol: 'TLSv1_2_method' })
|
|
})
|
|
|
|
t.test('ApiKey should take precedence over basic auth', t => {
|
|
t.plan(5)
|
|
const client = new Client({
|
|
cloud: {
|
|
// 'localhost$abcd$efgh'
|
|
id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA=='
|
|
},
|
|
auth: {
|
|
username: 'elastic',
|
|
password: 'changeme',
|
|
apiKey: 'Zm9vOmJhcg=='
|
|
}
|
|
})
|
|
|
|
const pool = client.connectionPool
|
|
t.ok(pool instanceof CloudConnectionPool)
|
|
t.match(pool.connections.find(c => c.id === 'https://abcd.localhost/'), {
|
|
url: new URL('https://elastic:changeme@abcd.localhost'),
|
|
id: 'https://abcd.localhost/',
|
|
headers: {
|
|
authorization: 'ApiKey Zm9vOmJhcg=='
|
|
},
|
|
ssl: { secureProtocol: 'TLSv1_2_method' },
|
|
deadCount: 0,
|
|
resurrectTimeout: 0,
|
|
roles: {
|
|
master: true,
|
|
data: true,
|
|
ingest: true,
|
|
ml: false
|
|
}
|
|
})
|
|
|
|
t.strictEqual(client.transport.compression, 'gzip')
|
|
t.strictEqual(client.transport.suggestCompression, true)
|
|
t.deepEqual(pool._ssl, { secureProtocol: 'TLSv1_2_method' })
|
|
})
|
|
|
|
t.test('Override default options', t => {
|
|
t.plan(4)
|
|
const client = new Client({
|
|
cloud: {
|
|
// 'localhost$abcd$efgh'
|
|
id: 'name:bG9jYWxob3N0JGFiY2QkZWZnaA==',
|
|
username: 'elastic',
|
|
password: 'changeme'
|
|
},
|
|
compression: false,
|
|
suggestCompression: false,
|
|
ssl: {
|
|
secureProtocol: 'TLSv1_1_method'
|
|
}
|
|
})
|
|
|
|
t.ok(client.connectionPool instanceof CloudConnectionPool)
|
|
t.strictEqual(client.transport.compression, false)
|
|
t.strictEqual(client.transport.suggestCompression, false)
|
|
t.deepEqual(client.connectionPool._ssl, { secureProtocol: 'TLSv1_1_method' })
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
test('Opaque Id support', t => {
|
|
t.test('No opaqueId', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.strictEqual(req.headers['x-opaque-id'], undefined)
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`
|
|
})
|
|
|
|
client.search({
|
|
index: 'test',
|
|
q: 'foo:bar'
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('No prefix', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.strictEqual(req.headers['x-opaque-id'], 'bar')
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`
|
|
})
|
|
|
|
client.search({
|
|
index: 'test',
|
|
q: 'foo:bar'
|
|
}, {
|
|
opaqueId: 'bar'
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.test('With prefix', t => {
|
|
t.plan(3)
|
|
|
|
function handler (req, res) {
|
|
t.strictEqual(req.headers['x-opaque-id'], 'foo-bar')
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
opaqueIdPrefix: 'foo-'
|
|
})
|
|
|
|
client.search({
|
|
index: 'test',
|
|
q: 'foo:bar'
|
|
}, {
|
|
opaqueId: 'bar'
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
t.end()
|
|
})
|
|
|
|
test('Correctly handles the same header cased differently', t => {
|
|
t.plan(4)
|
|
|
|
function handler (req, res) {
|
|
t.strictEqual(req.headers['authorization'], 'Basic foobar')
|
|
t.strictEqual(req.headers['foo'], 'baz')
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
auth: {
|
|
username: 'hello',
|
|
password: 'world'
|
|
},
|
|
headers: {
|
|
Authorization: 'Basic foobar',
|
|
Foo: 'bar'
|
|
}
|
|
})
|
|
|
|
client.search({
|
|
index: 'test',
|
|
q: 'foo:bar'
|
|
}, {
|
|
headers: {
|
|
foo: 'baz'
|
|
}
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|
|
|
|
test('Random selector', t => {
|
|
t.plan(2)
|
|
|
|
function handler (req, res) {
|
|
res.setHeader('Content-Type', 'application/json;utf=8')
|
|
res.end(JSON.stringify({ hello: 'world' }))
|
|
}
|
|
|
|
buildServer(handler, ({ port }, server) => {
|
|
const client = new Client({
|
|
node: `http://localhost:${port}`,
|
|
nodeSelector: 'random'
|
|
})
|
|
|
|
client.search({
|
|
index: 'test',
|
|
q: 'foo:bar'
|
|
}, (err, { body }) => {
|
|
t.error(err)
|
|
t.deepEqual(body, { hello: 'world' })
|
|
server.stop()
|
|
})
|
|
})
|
|
})
|