add allow_partial_request_body and allow_partial_expected_body

Author: potapovDim

.gitignore

@@ -8,4 +8,5 @@ b.js
 package-lock.json
 # index.html
 /lib/routes.js
-/misc/test.example.json
+/misc/test.example.json
+playground.*

.npmignore

@@ -7,4 +7,5 @@ specs
 examples
 .circleci
 index.html
-misc
+misc
+playground.*

Readme.md

@@ -156,14 +156,15 @@ const APIModelObject =   {
     }]
   },
   "request_body_equal": {             // this property will work with PUT, POST, DELETE, PATCH only
-      "status": 404,
-      "not_equal_response": {         // this field is optional, default is {"data": "invalid request"}
-         "success": false
-      },
-      "expected_body": {              // request body should equal expected_body property
-        "username": "test_",
-        "password": "test_pass"
-      }
+    "allow_partial_request_body": true, // allow send not all keys and get success response
+    "status": 404,
+    "not_equal_response": {         // this field is optional, default is {"data": "invalid request"}
+       "success": false
+    },
+    "expected_body": {              // request body should equal expected_body property
+      "username": "test",
+      "password": "test_pass"
+    }
   },
   "response": {                       // response is option field, default is {ok: 'OK'}
     "example": "example GET"
@@ -472,7 +473,10 @@ const indexHtmlText = await fetch('http://localhost:8081/', {method: 'GET'}).the
 ```js
 const fakeServer = require('test-fake-server')
 const fetch = require('node-fetch')
-const model_obj = {
+
+// full equalty check
+async function callToServer() {
+  const model_obj = {
   "port": "8081",
   "debug": true, // if this prop exists log will show all results in console, defailt is false
   "api": [{
@@ -491,18 +495,109 @@ const model_obj = {
     "response": {
       "success": true
     }
-  }]
+    }]
+  }
+
+  const serser = await fakeServer(model_obj)
+
+  const body_equal_success = await fetch('http://localhost:8081/test', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({"username": "test_", "password": "test_pass"})
+  }).then((res) => res.text())
+  // {"success":true}
+  console.log(body_equal_success)
+
+  const body_not_equal = await fetch('http://localhost:8081/test', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({
+      "username": "test_1",
+      "password": "test_pass"
+    })
+  }).then((res) => res.text())
+  // {"success": false}
+  console.log(body_not_equal)
+  await serser.stop()
 }
 
+async function callToServerPartialRequest() {
+  const model_obj = {
+    "port": "8081",
+    "debug": true, // if this prop exists log will show all results in console, defailt is false
+    "api": [{
+      "method": "POST",
+      "path": "/user",
+      "request_body_equal": {
+        "status": 404,
+        "not_equal_response": { // this field is optional, default is {"data": "invalid request"}
+          "success": false
+        },
+        "allow_partial_request_body": true,
+        "expected_body": {
+          "username": "test_",
+          "password": "test_pass"
+        }
+      },
+      "response": {
+        "success": true
+      }
+    }]
+  }
+
+  const serser = await fakeServer(model_obj)
 
+  const body_equal_success = await fetch('http://localhost:8081/test', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({"username": "test_",}) // partial body matches
+  }).then((res) => res.text())
+  // {"success":true}
+  console.log(body_equal_success)
+
+  const body_not_equal = await fetch('http://localhost:8081/test', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({
+      "username": "test_1",
+      "password": "test_pass"
+    })
+  }).then((res) => res.text())
+  // {"success": false}
+  console.log(body_not_equal)
+  await serser.stop()
+}
+
+async function callToServerPartialExpected() {
+  const model_obj = {
+    "port": "8081",
+    "debug": true, // if this prop exists log will show all results in console, defailt is false
+    "api": [{
+      "method": "POST",
+      "path": "/user",
+      "request_body_equal": {
+        "status": 404,
+        "not_equal_response": { // this field is optional, default is {"data": "invalid request"}
+          "success": false
+        },
+        "allow_partial_expected_body": true,
+        "expected_body": {
+          "username": "test_",
+          "password": "test_pass"
+        }
+      },
+      "response": {
+        "success": true
+      }
+    }]
+  }
 
-async function callToServer() {
   const serser = await fakeServer(model_obj)
 
   const body_equal_success = await fetch('http://localhost:8081/test', {
     method: 'POST',
     headers: {'Content-Type': 'application/json'},
-    body: JSON.stringify({"username": "test_", "password": "test_pass"})
+    body: JSON.stringify({"username": "test_", "password": "test_pass", "x": 2, "Y": 2}) // more that required keys are in request body
   }).then((res) => res.text())
   // {"success":true}
   console.log(body_equal_success)

lib/commons/equal_obj.js

@@ -1,3 +1,5 @@
+const { compareToPattern } = require('sat-utils')
+
 const is_arguments = function(object) {
   return Object.prototype.toString.call(object) == '[object Arguments]'
 }
@@ -22,7 +24,7 @@ const get_to_string = (arg) => {
   return Object.prototype.toString.call(arg)
 }
 
-function deep_equal(actual, expected) {
+function _deep_equal(actual, expected) {
   if(get_to_string(actual) !== get_to_string(expected)) {
     return false
   } else if(actual === expected) {
@@ -72,4 +74,17 @@ function obj_equiv(act, exp) {
   return typeof act === typeof exp
 }
 
+
+function deep_equal(actual, expected, {allow_partial_request_body, allow_partial_expected_body} = {}) {
+  if(allow_partial_request_body && allow_partial_expected_body) {
+    return compareToPattern(expected, actual).result || compareToPattern(actual, expected).result;
+  } else if (allow_partial_request_body) {
+    return compareToPattern(expected, actual).result
+  } else if(allow_partial_expected_body) {
+    return compareToPattern(actual, expected).result
+  } else {
+    return _deep_equal(actual, expected)
+  }
+}
+
 module.exports = {deep_equal}

lib/routing_templates/build_koa_router_model/body_equal.js

@@ -8,10 +8,14 @@ const {build_response_default} = require('./body_default')
  */
 function build_request_body_equal_response(body_equal, path, http_method) {
 
-  const {not_equal_response = {data: 'invalid request'}, status = 404, expected_body} = body_equal
+  const {not_equal_response = {data: 'invalid request'}, status = 404, expected_body, allow_partial_request_body, allow_partial_expected_body} = body_equal
 
   return `\n
-    if(!deep_equal(ctx.request.body, ${build_response_default(expected_body, path, http_method)})) {
+    if(!deep_equal(
+        ctx.request.body,
+        ${build_response_default(expected_body, path, http_method)},
+        {allow_partial_request_body: ${allow_partial_request_body}, allow_partial_expected_body: ${allow_partial_expected_body}})
+      ) {
       ctx.status = ${status}
       ctx.body = ${build_response_default(not_equal_response, path, http_method)}
       return ctx

lib/server_worker/index.js

@@ -1,5 +1,6 @@
+// @ts-check
 const Koa = require('koa')
-const Router = require('koa-router')
+const Router = require('@koa/router')
 const bodyParser = require('koa-bodyparser')
 const cors = require('@koa/cors')
 
@@ -13,6 +14,7 @@ module.exports = function(model) {
 
   function require_module_from_string(src, filename = '') {
     const Module = module.constructor
+    // @ts-ignore
     const mod = new Module()
     mod._compile(src, filename)
     return mod.exports
@@ -24,6 +26,7 @@ module.exports = function(model) {
 
   // if fake server model contains authorization property
   // next execution will set koa-bearer-token middleware
+  // @ts-ignore
   set_authorization_middleware(app, model)
   app.use(cors())
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "test-fake-server",
-  "version": "2.6.0",
+  "version": "2.7.0",
   "description": "simple way to create node http server",
   "main": "index.js",
   "bin": {
@@ -34,19 +34,19 @@
     "url": "https://github.com/potapovDim/test-fake-server/issues"
   },
   "dependencies": {
-    "@koa/cors": "^2.2.3",
+    "@koa/cors": "^3.4.2",
+    "@koa/router": "^12.0.0",
+    "koa": "^2.13.4",
     "koa-bearer-token": "^1.0.0",
     "koa-bodyparser": "^4.3.0",
     "koa-logger": "^3.2.0",
-    "koa-router": "^7.4.0",
-    "koa": "^2.12.0",
     "minimist": "^1.2.5",
-    "node-fetch": "^2.6.1"
+    "node-fetch": "^2.6.1",
+    "sat-utils": "^1.0.1"
   },
   "homepage": "https://github.com/potapovDim/test-fake-server#readme",
   "devDependencies": {
     "ajv": "^6.12.2",
-    "axios": "^0.19.2",
     "chai": "^4.1.2",
     "mocha": "^5.2.0"
   }

specs/body_equal.partial_expected.spec.js

@@ -0,0 +1,58 @@
+const fakeServer = require('../index')
+const fetch = require('node-fetch')
+const {expect} = require('chai')
+
+describe('Body equal gets allow_partial_expected_body', () => {
+  let server = null
+  const model_obj = {
+    "port": 8888,
+    "api": [{
+      "method": "POST",
+      "path": "/user",
+      "request_body_equal": {
+        "status": 404,
+        "allow_partial_expected_body": true,
+        "expected_body": {
+          "username": "test",
+          "password": "test_pass"
+        }
+      },
+      "response": {
+        "success": true
+      }
+    }]
+  }
+  beforeEach(async () => {
+    server = await fakeServer(model_obj)
+  })
+  afterEach(async () => {
+    await server.stop()
+  })
+
+  it('success', async function() {
+    const responseBody = await fetch('http://localhost:8888/user', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({"username": "test", "password": "test_pass"})
+    }).then((res) => res.json())
+    expect(responseBody.success).to.eql(true)
+  })
+
+  it('[more_than_required_keys] success', async function() {
+    const responseBody = await fetch('http://localhost:8888/user', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({"username": "test", "password": "test_pass", "x": 2, "Y": 2})
+    }).then((res) => res.json())
+    expect(responseBody.success).to.eql(true)
+  })
+
+  it('invalid', async function() {
+    const responseBody = await fetch('http://localhost:8888/user', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({"username": "test---", "password": "test_pass"})
+    }).then((res) => res.json())
+    expect(responseBody.data).to.eql('invalid request')
+  })
+})

specs/body_equal.partial_request.spec.js

@@ -0,0 +1,58 @@
+const fakeServer = require('../index')
+const fetch = require('node-fetch')
+const {expect} = require('chai')
+
+describe('Body equal gets allow_partial_request_body', () => {
+  let server = null
+  const model_obj = {
+    "port": 8888,
+    "api": [{
+      "method": "POST",
+      "path": "/user",
+      "request_body_equal": {
+        "status": 404,
+        "allow_partial_request_body": true,
+        "expected_body": {
+          "username": "test",
+          "password": "test_pass"
+        }
+      },
+      "response": {
+        "success": true
+      }
+    }]
+  }
+  beforeEach(async () => {
+    server = await fakeServer(model_obj)
+  })
+  afterEach(async () => {
+    await server.stop()
+  })
+
+  it('success', async function() {
+    const responseBody = await fetch('http://localhost:8888/user', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({"username": "test"})
+    }).then((res) => res.json())
+    expect(responseBody.success).to.eql(true)
+  })
+
+  it('[not_all_keys] success', async function() {
+    const responseBody = await fetch('http://localhost:8888/user', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({"username": "test"})
+    }).then((res) => res.json())
+    expect(responseBody.success).to.eql(true)
+  })
+
+  it('invalid', async function() {
+    const responseBody = await fetch('http://localhost:8888/user', {
+      method: 'POST',
+      headers: {'Content-Type': 'application/json'},
+      body: JSON.stringify({"username": "test---", "password": "test_pass"})
+    }).then((res) => res.json())
+    expect(responseBody.data).to.eql('invalid request')
+  })
+})