Merge pull request #2492 from kuzzleio/2.27.1-proposal

jest/api/controller/document/mCreate.test.ts

@@ -0,0 +1,159 @@
+import { Kuzzle, WebSocket } from 'kuzzle-sdk';
+
+const kuzzle = new Kuzzle(new WebSocket('localhost'));
+const index = 'nyc-open-data';
+const collection = 'yellow-taxi';
+
+beforeAll(async () => {
+ await kuzzle.connect();
+ await kuzzle.index.create(index);
+ await kuzzle.collection.create(index, collection, {
+ mappings: {
+ properties: {
+ value: {
+ type: 'keyword'
+ },
+ field: {
+ properties: {
+ path: {
+ type: 'keyword'
+ }
+ }
+ }
+ }
+ }
+ });
+});
+
+afterAll(async () => {
+ await kuzzle.index.delete(index);
+ await kuzzle.disconnect();
+});
+
+describe('mCreate', () => {
+ afterEach(async () => {
+ await kuzzle.collection.truncate(index, collection);
+ });
+
+
+ it('It should create document if not exists', async () => {
+ const mCreateResult = await kuzzle.document.mCreate(index, collection, [
+ {
+ _id: 'A',
+ body: {
+ value: 'A'
+ }
+ }
+ ], {
+ refresh: 'wait_for'
+ });
+
+ expect(mCreateResult.successes.length).toEqual(1);
+
+ const result = await kuzzle.document.mGet(index, collection, ['A']);
+
+ expect(result.successes.length).toEqual(1);
+ expect(result.successes[0]._source).toMatchObject({
+ value: 'A'
+ });
+ });
+
+ it('It should not replace the document if not exists', async () => {
+ let mCreateResult = await kuzzle.document.mCreate(index, collection, [
+ {
+ _id: 'A',
+ body: {
+ value: 'A'
+ }
+ }
+ ], {
+ refresh: 'wait_for'
+ });
+
+ expect(mCreateResult.successes.length).toEqual(1);
+
+ mCreateResult = await kuzzle.document.mCreate(index, collection, [
+ {
+ _id: 'A',
+ body: {
+ value: 'FOO'
+ }
+ }
+ ], {
+ refresh: 'wait_for'
+ });
+
+ expect(mCreateResult.successes.length).toEqual(0);
+ expect(mCreateResult.errors.length).toEqual(1);
+
+ const result = await kuzzle.document.mGet(index, collection, ['A']);
+
+ expect(result.successes.length).toEqual(1);
+ expect(result.successes[0]._source).toMatchObject({
+ value: 'A'
+ });
+ });
+
+
+ it('It should not replace the document even if the previous document did not exist', async () => {
+ let mCreateResult = await kuzzle.document.mCreate(index, collection, [
+ {
+ _id: 'A',
+ body: {
+ value: 'A'
+ }
+ },
+ {
+ _id: 'C',
+ body: {
+ value: 'C'
+ }
+ }
+ ], {
+ refresh: 'wait_for'
+ });
+
+ expect(mCreateResult.successes.length).toEqual(2);
+
+ mCreateResult = await kuzzle.document.mCreate(index, collection, [
+ {
+ _id: 'A',
+ body: {
+ value: 'FOO'
+ }
+ },
+ {
+ _id: 'B',
+ body: {
+ value: 'B'
+ }
+ },
+ {
+ _id: 'C',
+ body: {
+ value: 'FOO'
+ }
+ }
+ ], {
+ refresh: 'wait_for'
+ });
+
+ expect(mCreateResult.successes.length).toEqual(1);
+ expect(mCreateResult.errors.length).toEqual(2);
+
+ const result = await kuzzle.document.mGet(index, collection, ['A', 'B', 'C']);
+
+ expect(result.successes.length).toEqual(3);
+ expect(result.successes[0]._source).toMatchObject({
+ value: 'A'
+ });
+ expect(result.successes[1]._source).toMatchObject({
+ value: 'B'
+ });
+ expect(result.successes[2]._source).toMatchObject({
+ value: 'C'
+ });
+ });
+
+
+});

lib/core/network/protocols/httpwsProtocol.js

@@ -498,23 +498,30 @@ class HttpWsProtocol extends Protocol {
  return;
  }
 
- const contentType = message.headers["content-type"];
+ const contentTypeHeader = message.headers["content-type"];
 
- if (
- contentType &&
- !this.httpConfig.opts.allowedContentTypes.some((allowed) =>
- contentType.includes(allowed)
- )
- ) {
- this.httpSendError(
- message,
- response,
- kerrorHTTP.get("unsupported_content", contentType)
- );
- return;
+ if (contentTypeHeader) {
+ const contentTypeParamIndex = contentTypeHeader.indexOf(";");
+ const contentType =
+ contentTypeParamIndex !== -1
+ ? contentTypeHeader.slice(0, contentTypeParamIndex).trim()
+ : contentTypeHeader.trim();
+
+ if (
+ !this.httpConfig.opts.allowedContentTypes.some(
+ (allowed) => contentType === allowed
+ )
+ ) {
+ this.httpSendError(
+ message,
+ response,
+ kerrorHTTP.get("unsupported_content", contentType)
+ );
+ return;
+ }
  }
 
- const encoding = CHARSET_REGEX.exec(contentType);
+ const encoding = CHARSET_REGEX.exec(contentTypeHeader);
 
  if (encoding !== null && encoding[1].toLowerCase() !== "utf-8") {
  this.httpSendError(

lib/service/storage/elasticsearch.js

@@ -2261,8 +2261,6 @@ class ElasticSearch extends Service {
  reason: "document already exists",
  status: 400,
  });
-
- idx++;
  } else {
  esRequest.body.push({
  index: {
@@ -2274,6 +2272,7 @@ class ElasticSearch extends Service {
 
  toImport.push(document);
  }
+ idx++;
  } else {
  esRequest.body.push({ index: { _index: alias } });
  esRequest.body.push(document._source);

package.json

@@ -1,7 +1,7 @@
 {
  "name": "kuzzle",
  "author": "The Kuzzle Team <[email protected]>",
- "version": "2.27.0",
+ "version": "2.27.1",
  "description": "Kuzzle is an open-source solution that handles all the data management through a secured API, with a large choice of protocols.",
  "bin": "bin/start-kuzzle-server",
  "scripts": {

test/core/network/protocols/http.test.js

@@ -357,6 +357,20 @@ describe("core/network/protocols/http", () => {
  });
  });
 
+ it("should reject requests with supported content types with extraneous characters", () => {
+ httpWs.server._httpOnMessage("get", "/", "", {
+ "content-type": "serge application/jsoncheval",
+ });
+
+ should(entryPoint.newConnection).not.called();
+ should(global.kuzzle.router.http.route).not.called();
+ should(httpWs.httpSendError)
+ .calledOnce()
+ .calledWithMatch(sinon.match.object, httpWs.server._httpResponse, {
+ id: "network.http.unsupported_content",
+ });
+ });
+
  it("should reject requests with unhandled charsets", () => {
  httpWs.server._httpOnMessage("get", "/", "", {
  "content-type": "application/json; charset=utf-82",