From 72333fdb55df9b0e95aeaddbc5c2fde5bd7d5ed1 Mon Sep 17 00:00:00 2001 From: shadyzoz Date: Wed, 17 Jun 2020 20:58:32 +0800 Subject: [PATCH] fix: replace upload fixture image.png with a smaller upload.txt (#563) --- test/__snapshots__/basic.spec.js.snap | 20 +- test/basic.spec.js | 247 ++++++++++++++++++ ...image.png with a smaller upload.txt (#563) | 247 ++++++++++++++++++ test/fixtures/image.png | Bin 7181 -> 0 bytes test/fixtures/upload.txt | 1 + test/rule/beforeDealHttpsRequest.spec.js | 4 +- test/rule/beforeSendRequest.spec.js | 8 +- 7 files changed, 517 insertions(+), 10 deletions(-) create mode 100644 test/basic.spec.js create mode 100644 test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) delete mode 100644 test/fixtures/image.png create mode 100644 test/fixtures/upload.txt diff --git a/test/__snapshots__/basic.spec.js.snap b/test/__snapshots__/basic.spec.js.snap index c7dc7ef..3d3b398 100644 --- a/test/__snapshots__/basic.spec.js.snap +++ b/test/__snapshots__/basic.spec.js.snap @@ -22,11 +22,17 @@ exports[`http - HTTP verbs PATCH: data 1`] = `""`; exports[`http - HTTP verbs POST body and header: args 1`] = `Object {}`; -exports[`http - HTTP verbs POST body and header: data 1`] = `"data:application/octet-stream;base64,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"`; +exports[`http - HTTP verbs POST body and header: data 1`] = ` +"1 +" +`; exports[`http - HTTP verbs PUT: args 1`] = `Object {}`; -exports[`http - HTTP verbs PUT: data 1`] = `"data:application/octet-stream;base64,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"`; +exports[`http - HTTP verbs PUT: data 1`] = ` +"1 +" +`; exports[`https - HTTP verbs DELETE: args 1`] = ` Object { @@ -50,8 +56,14 @@ exports[`https - HTTP verbs PATCH: data 1`] = `""`; exports[`https - HTTP verbs POST body and header: args 1`] = `Object {}`; -exports[`https - HTTP verbs POST body and header: data 1`] = `"data:application/octet-stream;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAKy2lDQ1BJQ0MgUHJvZmlsZQAASImVlwdUk1kWx9/3pYeEAIEISAm9CVIEAkgJPYDSq6iEJJBQQkgICnZEHIERQUQEywgMiig4KkVGUbFgRbFhnyCDiDoOFmyo7AcsYWb37O7Zf8473y8399373jvv5twPADKeLRKlwUoApAuzxGF+nvSY2Dg67ncAAQLyIQKIzZGImCEhQQDR9PPv+nAX8UZ0y3Ii1r///l+lzOVJOABAIQgnciWcdISPIeM1RyTOAgBVh9gNlmWJJvgiwqpiZIEIP5rg5CkemeDESUajJ30iwrwQVgcAT2KzxckAkAwROz2bk4zEIXkjbC3kCoQII9+BG4fP5iKM5AVz0tMzJliGsGniX+Ik/y1mojwmm50s56m9TArvLZCI0tg5/+dx/G+lp0mncxgjg8QX+4chTxpyZvdSMwLlLExcGDzNAu6k/yTzpf6R08yReMVNM5ftHSifm7YwaJqTBL4seZwsVsQ08yQ+4dMszgiT50oSezGnmS2eyStNjZTb+TyWPH4uPyJ6mrMFUQunWZIaHjjj4yW3i6Vh8vXzhH6eM3l95XtPl/xlvwKWfG4WP8Jfvnf2zPp5QuZMTEmMfG1cnrfPjE+k3F+U5SnPJUoLkfvz0vzkdkl2uHxuFnIhZ+aGyM8whR0QMs0gCPgBOogEaSALiAEbYX+A3NQs3vKJOwq8MkQ5YkEyP4vORKqMR2cJOVZz6LbWttYATNTs1JV4FzZZixCtc8aWgdQQ4wNSJ6UztsRyANoKAFB/MGMz3A0AJR+A1i6OVJw9ZZsoJ4BB/gcoQBVoAB1gAEyBJbAFDsAFeAAfEACCQQSIBUsAB/BBOrLyZWAlWAcKQBHYAraBKrAH1IL94BA4AtrACXAGXABXwA1wBzwEMjAIXoIR8AGMQRCEg8gQFdKAdCEjyAKyhRiQG+QDBUFhUCyUACVDQkgKrYTWQ0VQGVQF7YUaoF+g49AZ6BLUC92H+qFh6C30BUbBJFgV1oaN4bkwA2bCgXAEvBhOhjPhXDgf3gxXwjXwQbgVPgNfge/AMvglPIoCKAUUDaWHskQxUF6oYFQcKgklRq1GFaIqUDWoJlQHqht1CyVDvUJ9RmPRVDQdbYl2QfujI9EcdCZ6NboYXYXej25Fn0PfQvejR9DfMWSMFsYC44xhYWIwyZhlmAJMBaYe04I5j7mDGcR8wGKxNKwJ1hHrj43FpmBXYIuxu7DN2NPYXuwAdhSHw2ngLHCuuGAcG5eFK8DtwB3EncLdxA3iPuEV8Lp4W7wvPg4vxOfhK/AH8J34m/gh/BhBiWBEcCYEE7iEHEIJoY7QQbhOGCSMEZWJJkRXYgQxhbiOWElsIp4nPiK+U1BQ0FdwUghVECisVahUOKxwUaFf4TNJhWRO8iLFk6SkzaR9pNOk+6R3ZDLZmOxBjiNnkTeTG8hnyU/InxSpilaKLEWu4hrFasVWxZuKrykEihGFSVlCyaVUUI5SrlNeKRGUjJW8lNhKq5WqlY4r9SmNKlOVbZSDldOVi5UPKF9Sfq6CUzFW8VHhquSr1KqcVRmgoqgGVC8qh7qeWkc9Tx1UxaqaqLJUU1SLVA+p9qiOqKmozVOLUluuVq12Uk1GQ9GMaSxaGq2EdoR2l/ZllvYs5izerE2zmmbdnPVRfba6hzpPvVC9Wf2O+hcNuoaPRqpGqUabxmNNtKa5ZqjmMs3dmuc1X81Wne0ymzO7cPaR2Q+0YC1zrTCtFVq1Wle1RrV1tP20Rdo7tM9qv9Kh6XjopOiU63TqDOtSdd10Bbrluqd0X9DV6Ex6Gr2Sfo4+oqel568n1dur16M3pm+iH6mfp9+s/9iAaMAwSDIoN+gyGDHUNVxguNKw0fCBEcGIYcQ32m7UbfTR2MQ42nijcZvxcxN1E5ZJrkmjySNTsqm7aaZpjeltM6wZwyzVbJfZDXPY3N6cb15tft0CtnCwEFjssuidg5njNEc4p2ZOnyXJkmmZbdlo2W9FswqyyrNqs3o913Bu3NzSud1zv1vbW6dZ11k/tFGxCbDJs+mweWtrbsuxrba9bUe287VbY9du92aexTzevN3z7tlT7RfYb7Tvsv/m4OggdmhyGHY0dExw3OnYx1BlhDCKGRedME6eTmucTjh9dnZwznI+4vyni6VLqssBl+fzTebz5tfNH3DVd2W77nWVudHdEtx+cpO567mz3Wvcn3oYeHA96j2GmGbMFOZB5mtPa0+xZ4vnRy9nr1Vep71R3n7ehd49Pio+kT5VPk989X2TfRt9R/zs/Vb4nfbH+Af6l/r3sbRZHFYDayTAMWBVwLlAUmB4YFXg0yDzIHFQxwJ4QcCCrQseLTRaKFzYFgyCWcFbgx+HmIRkhvwaig0NCa0OfRZmE7YyrDucGr40/ED4hwjPiJKIh5GmkdLIrihKVHxUQ9THaO/osmhZzNyYVTFXYjVjBbHtcbi4qLj6uNFFPou2LRqMt48viL+72GTx8sWXlmguSVtycillKXvp0QRMQnTCgYSv7GB2DXs0kZW4M3GE48XZznnJ9eCWc4d5rrwy3lCSa1JZ0vNk1+StycN8d34F/5XAS1AleJPin7In5WNqcOq+1PG06LTmdHx6QvpxoYowVXguQydjeUavyEJUIJJlOmduyxwRB4rrJZBksaQ9SxVpjq5KTaUbpP3ZbtnV2Z+WRS07ulx5uXD51RzznE05Q7m+uT+vQK/grOhaqbdy3cr+VcxVe1dDqxNXd60xWJO/ZnCt39r964jrUtddy7POK8t7vz56fUe+dv7a/IENfhsaCxQLxAV9G1027vkB/YPgh55Ndpt2bPpeyC28XGRdVFH0tZhTfPlHmx8rfxzfnLS5p8ShZPcW7Bbhlrul7qX7y5TLcssGti7Y2lpOLy8sf79t6bZLFfMq9mwnbpdul1UGVbbvMNyxZcfXKn7VnWrP6uadWjs37fy4i7vr5m6P3U17tPcU7fnyk+Cne3v99rbWGNdU1GJrs2uf1UXVdf/M+LmhXrO+qP7bPuE+2f6w/ecaHBsaDmgdKGmEG6WNwwfjD9445H2ovcmyaW8zrbnoMDgsPfzil4Rf7h4JPNJ1lHG06ZjRsZ0t1JbCVqg1p3Wkjd8ma49t7z0ecLyrw6Wj5VerX/ed0DtRfVLtZEknsTO/c/xU7qnR06LTr84knxnoWtr18GzM2dvnQs/1nA88f/GC74Wz3czuUxddL5645Hzp+GXG5bYrDldar9pfbblmf62lx6Gn9brj9fYbTjc6euf3dt50v3nmlvetC7dZt6/cWXin927k3Xt98X2ye9x7z++n3X/zIPvB2MO1jzCPCh8rPa54ovWk5jez35plDrKT/d79V5+GP304wBl4+bvk96+D+c/IzyqGdIcants+PzHsO3zjxaIXgy9FL8deFfyh/MfO16avj/3p8efVkZiRwTfiN+Nvi99pvNv3ft77rtGQ0Scf0j+MfSz8pPFp/2fG5+4v0V+GxpZ9xX2t/Gb2reN74PdH4+nj4yK2mD3ZCqCQASclAfB2HwDkWACoNwAgLprqqScFTb0HTBL4TzzVd0/KAYDaPgAiVgAQdA2AHVVIS4vEp8QDEEJB7C4AtrOTj39KkmRnOxWL5I60Jo/Hx9+ZAoArBeBb6fj4WO34+LdaZLEPATidM9XLT0gHea9YRACwZ9Tthvq14F/0D2jREwezjIEpAAAAimVYSWZNTQAqAAAACAAEARoABQAAAAEAAAA+ARsABQAAAAEAAABGASgAAwAAAAEAAgAAh2kABAAAAAEAAABOAAAAAAAAAJAAAAABAAAAkAAAAAEAA5KGAAcAAAASAAAAeKACAAQAAAABAAABkKADAAQAAAABAAABkAAAAABBU0NJSQAAAFNjcmVlbnNob3SeZrH8AAAACXBIWXMAABYlAAAWJQFJUiTwAAAB1mlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS40LjAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyI+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj40MDA8L2V4aWY6UGl4ZWxYRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpVc2VyQ29tbWVudD5TY3JlZW5zaG90PC9leGlmOlVzZXJDb21tZW50PgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+NDAwPC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CmMeW/IAAAAcaURPVAAAAAIAAAAAAAAAyAAAACgAAADIAAAAyAAAB1NdjsJUAAAHH0lEQVR4AezVsQkAIBAEQW3k++9SwQ7ceIz9ZDjYPTNneQQIECBA4FNgC8inmO8ECBAg8AQExBAIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgMAFAAD//3r1jsgAAAcdSURBVO3VsQkAIBAEQW3k++9SwQ7ceIz9ZDjYPTNneQQIECBA4FNgC8inmO8ECBAg8AQExBAIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgMAFw20cv5WvzCgAAAAASUVORK5CYII="`; +exports[`https - HTTP verbs POST body and header: data 1`] = ` +"1 +" +`; exports[`https - HTTP verbs PUT: args 1`] = `Object {}`; -exports[`https - HTTP verbs PUT: data 1`] = `"data:application/octet-stream;base64,iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAYAAACAvzbMAAAKy2lDQ1BJQ0MgUHJvZmlsZQAASImVlwdUk1kWx9/3pYeEAIEISAm9CVIEAkgJPYDSq6iEJJBQQkgICnZEHIERQUQEywgMiig4KkVGUbFgRbFhnyCDiDoOFmyo7AcsYWb37O7Zf8473y8399373jvv5twPADKeLRKlwUoApAuzxGF+nvSY2Dg67ncAAQLyIQKIzZGImCEhQQDR9PPv+nAX8UZ0y3Ii1r///l+lzOVJOABAIQgnciWcdISPIeM1RyTOAgBVh9gNlmWJJvgiwqpiZIEIP5rg5CkemeDESUajJ30iwrwQVgcAT2KzxckAkAwROz2bk4zEIXkjbC3kCoQII9+BG4fP5iKM5AVz0tMzJliGsGniX+Ik/y1mojwmm50s56m9TArvLZCI0tg5/+dx/G+lp0mncxgjg8QX+4chTxpyZvdSMwLlLExcGDzNAu6k/yTzpf6R08yReMVNM5ftHSifm7YwaJqTBL4seZwsVsQ08yQ+4dMszgiT50oSezGnmS2eyStNjZTb+TyWPH4uPyJ6mrMFUQunWZIaHjjj4yW3i6Vh8vXzhH6eM3l95XtPl/xlvwKWfG4WP8Jfvnf2zPp5QuZMTEmMfG1cnrfPjE+k3F+U5SnPJUoLkfvz0vzkdkl2uHxuFnIhZ+aGyM8whR0QMs0gCPgBOogEaSALiAEbYX+A3NQs3vKJOwq8MkQ5YkEyP4vORKqMR2cJOVZz6LbWttYATNTs1JV4FzZZixCtc8aWgdQQ4wNSJ6UztsRyANoKAFB/MGMz3A0AJR+A1i6OVJw9ZZsoJ4BB/gcoQBVoAB1gAEyBJbAFDsAFeAAfEACCQQSIBUsAB/BBOrLyZWAlWAcKQBHYAraBKrAH1IL94BA4AtrACXAGXABXwA1wBzwEMjAIXoIR8AGMQRCEg8gQFdKAdCEjyAKyhRiQG+QDBUFhUCyUACVDQkgKrYTWQ0VQGVQF7YUaoF+g49AZ6BLUC92H+qFh6C30BUbBJFgV1oaN4bkwA2bCgXAEvBhOhjPhXDgf3gxXwjXwQbgVPgNfge/AMvglPIoCKAUUDaWHskQxUF6oYFQcKgklRq1GFaIqUDWoJlQHqht1CyVDvUJ9RmPRVDQdbYl2QfujI9EcdCZ6NboYXYXej25Fn0PfQvejR9DfMWSMFsYC44xhYWIwyZhlmAJMBaYe04I5j7mDGcR8wGKxNKwJ1hHrj43FpmBXYIuxu7DN2NPYXuwAdhSHw2ngLHCuuGAcG5eFK8DtwB3EncLdxA3iPuEV8Lp4W7wvPg4vxOfhK/AH8J34m/gh/BhBiWBEcCYEE7iEHEIJoY7QQbhOGCSMEZWJJkRXYgQxhbiOWElsIp4nPiK+U1BQ0FdwUghVECisVahUOKxwUaFf4TNJhWRO8iLFk6SkzaR9pNOk+6R3ZDLZmOxBjiNnkTeTG8hnyU/InxSpilaKLEWu4hrFasVWxZuKrykEihGFSVlCyaVUUI5SrlNeKRGUjJW8lNhKq5WqlY4r9SmNKlOVbZSDldOVi5UPKF9Sfq6CUzFW8VHhquSr1KqcVRmgoqgGVC8qh7qeWkc9Tx1UxaqaqLJUU1SLVA+p9qiOqKmozVOLUluuVq12Uk1GQ9GMaSxaGq2EdoR2l/ZllvYs5izerE2zmmbdnPVRfba6hzpPvVC9Wf2O+hcNuoaPRqpGqUabxmNNtKa5ZqjmMs3dmuc1X81Wne0ymzO7cPaR2Q+0YC1zrTCtFVq1Wle1RrV1tP20Rdo7tM9qv9Kh6XjopOiU63TqDOtSdd10Bbrluqd0X9DV6Ex6Gr2Sfo4+oqel568n1dur16M3pm+iH6mfp9+s/9iAaMAwSDIoN+gyGDHUNVxguNKw0fCBEcGIYcQ32m7UbfTR2MQ42nijcZvxcxN1E5ZJrkmjySNTsqm7aaZpjeltM6wZwyzVbJfZDXPY3N6cb15tft0CtnCwEFjssuidg5njNEc4p2ZOnyXJkmmZbdlo2W9FswqyyrNqs3o913Bu3NzSud1zv1vbW6dZ11k/tFGxCbDJs+mweWtrbsuxrba9bUe287VbY9du92aexTzevN3z7tlT7RfYb7Tvsv/m4OggdmhyGHY0dExw3OnYx1BlhDCKGRedME6eTmucTjh9dnZwznI+4vyni6VLqssBl+fzTebz5tfNH3DVd2W77nWVudHdEtx+cpO567mz3Wvcn3oYeHA96j2GmGbMFOZB5mtPa0+xZ4vnRy9nr1Vep71R3n7ehd49Pio+kT5VPk989X2TfRt9R/zs/Vb4nfbH+Af6l/r3sbRZHFYDayTAMWBVwLlAUmB4YFXg0yDzIHFQxwJ4QcCCrQseLTRaKFzYFgyCWcFbgx+HmIRkhvwaig0NCa0OfRZmE7YyrDucGr40/ED4hwjPiJKIh5GmkdLIrihKVHxUQ9THaO/osmhZzNyYVTFXYjVjBbHtcbi4qLj6uNFFPou2LRqMt48viL+72GTx8sWXlmguSVtycillKXvp0QRMQnTCgYSv7GB2DXs0kZW4M3GE48XZznnJ9eCWc4d5rrwy3lCSa1JZ0vNk1+StycN8d34F/5XAS1AleJPin7In5WNqcOq+1PG06LTmdHx6QvpxoYowVXguQydjeUavyEJUIJJlOmduyxwRB4rrJZBksaQ9SxVpjq5KTaUbpP3ZbtnV2Z+WRS07ulx5uXD51RzznE05Q7m+uT+vQK/grOhaqbdy3cr+VcxVe1dDqxNXd60xWJO/ZnCt39r964jrUtddy7POK8t7vz56fUe+dv7a/IENfhsaCxQLxAV9G1027vkB/YPgh55Ndpt2bPpeyC28XGRdVFH0tZhTfPlHmx8rfxzfnLS5p8ShZPcW7Bbhlrul7qX7y5TLcssGti7Y2lpOLy8sf79t6bZLFfMq9mwnbpdul1UGVbbvMNyxZcfXKn7VnWrP6uadWjs37fy4i7vr5m6P3U17tPcU7fnyk+Cne3v99rbWGNdU1GJrs2uf1UXVdf/M+LmhXrO+qP7bPuE+2f6w/ecaHBsaDmgdKGmEG6WNwwfjD9445H2ovcmyaW8zrbnoMDgsPfzil4Rf7h4JPNJ1lHG06ZjRsZ0t1JbCVqg1p3Wkjd8ma49t7z0ecLyrw6Wj5VerX/ed0DtRfVLtZEknsTO/c/xU7qnR06LTr84knxnoWtr18GzM2dvnQs/1nA88f/GC74Wz3czuUxddL5645Hzp+GXG5bYrDldar9pfbblmf62lx6Gn9brj9fYbTjc6euf3dt50v3nmlvetC7dZt6/cWXin927k3Xt98X2ye9x7z++n3X/zIPvB2MO1jzCPCh8rPa54ovWk5jez35plDrKT/d79V5+GP304wBl4+bvk96+D+c/IzyqGdIcants+PzHsO3zjxaIXgy9FL8deFfyh/MfO16avj/3p8efVkZiRwTfiN+Nvi99pvNv3ft77rtGQ0Scf0j+MfSz8pPFp/2fG5+4v0V+GxpZ9xX2t/Gb2reN74PdH4+nj4yK2mD3ZCqCQASclAfB2HwDkWACoNwAgLprqqScFTb0HTBL4TzzVd0/KAYDaPgAiVgAQdA2AHVVIS4vEp8QDEEJB7C4AtrOTj39KkmRnOxWL5I60Jo/Hx9+ZAoArBeBb6fj4WO34+LdaZLEPATidM9XLT0gHea9YRACwZ9Tthvq14F/0D2jREwezjIEpAAAAimVYSWZNTQAqAAAACAAEARoABQAAAAEAAAA+ARsABQAAAAEAAABGASgAAwAAAAEAAgAAh2kABAAAAAEAAABOAAAAAAAAAJAAAAABAAAAkAAAAAEAA5KGAAcAAAASAAAAeKACAAQAAAABAAABkKADAAQAAAABAAABkAAAAABBU0NJSQAAAFNjcmVlbnNob3SeZrH8AAAACXBIWXMAABYlAAAWJQFJUiTwAAAB1mlUWHRYTUw6Y29tLmFkb2JlLnhtcAAAAAAAPHg6eG1wbWV0YSB4bWxuczp4PSJhZG9iZTpuczptZXRhLyIgeDp4bXB0az0iWE1QIENvcmUgNS40LjAiPgogICA8cmRmOlJERiB4bWxuczpyZGY9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkvMDIvMjItcmRmLXN5bnRheC1ucyMiPgogICAgICA8cmRmOkRlc2NyaXB0aW9uIHJkZjphYm91dD0iIgogICAgICAgICAgICB4bWxuczpleGlmPSJodHRwOi8vbnMuYWRvYmUuY29tL2V4aWYvMS4wLyI+CiAgICAgICAgIDxleGlmOlBpeGVsWERpbWVuc2lvbj40MDA8L2V4aWY6UGl4ZWxYRGltZW5zaW9uPgogICAgICAgICA8ZXhpZjpVc2VyQ29tbWVudD5TY3JlZW5zaG90PC9leGlmOlVzZXJDb21tZW50PgogICAgICAgICA8ZXhpZjpQaXhlbFlEaW1lbnNpb24+NDAwPC9leGlmOlBpeGVsWURpbWVuc2lvbj4KICAgICAgPC9yZGY6RGVzY3JpcHRpb24+CiAgIDwvcmRmOlJERj4KPC94OnhtcG1ldGE+CmMeW/IAAAAcaURPVAAAAAIAAAAAAAAAyAAAACgAAADIAAAAyAAAB1NdjsJUAAAHH0lEQVR4AezVsQkAIBAEQW3k++9SwQ7ceIz9ZDjYPTNneQQIECBA4FNgC8inmO8ECBAg8AQExBAIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgMAFAAD//3r1jsgAAAcdSURBVO3VsQkAIBAEQW3k++9SwQ7ceIz9ZDjYPTNneQQIECBA4FNgC8inmO8ECBAg8AQExBAIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgICA2AABAgQIJAEBSWyOCBAgQEBAbIAAAQIEkoCAJDZHBAgQICAgNkCAAAECSUBAEpsjAgQIEBAQGyBAgACBJCAgic0RAQIECAiIDRAgQIBAEhCQxOaIAAECBATEBggQIEAgCQhIYnNEgAABAgJiAwQIECCQBAQksTkiQIAAAQGxAQIECBBIAgKS2BwRIECAgIDYAAECBAgkAQFJbI4IECBAQEBsgAABAgSSgIAkNkcECBAgICA2QIAAAQJJQEASmyMCBAgQEBAbIECAAIEkICCJzREBAgQICIgNECBAgEASEJDE5ogAAQIEBMQGCBAgQCAJCEhic0SAAAECAmIDBAgQIJAEBCSxOSJAgAABAbEBAgQIEEgCApLYHBEgQICAgNgAAQIECCQBAUlsjggQIEBAQGyAAAECBJKAgCQ2RwQIECAgIDZAgAABAklAQBKbIwIECBAQEBsgQIAAgSQgIInNEQECBAgIiA0QIECAQBIQkMTmiAABAgQExAYIECBAIAkISGJzRIAAAQICYgMECBAgkAQEJLE5IkCAAAEBsQECBAgQSAICktgcESBAgMAFw20cv5WvzCgAAAAASUVORK5CYII="`; +exports[`https - HTTP verbs PUT: data 1`] = ` +"1 +" +`; diff --git a/test/basic.spec.js b/test/basic.spec.js new file mode 100644 index 0000000..84206d2 --- /dev/null +++ b/test/basic.spec.js @@ -0,0 +1,247 @@ + +process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; +const path = require('path'); +const fs = require('fs'); +const urllib = require('urllib'); +const request = require('request'); +const { basicProxyRequest, proxyServerWithRule, } = require('./util.js'); +const http = require('http'); +const WebSocket = require('ws'); +const tunnel = require('tunnel'); + +let proxyServer; +let proxyPort; +let proxyHost; +let proxyWebInterfaceHost; +beforeAll(async () => { + jest.DEFAULT_TIMEOUT_INTERVAL = 20 * 1000; + proxyServer = await proxyServerWithRule({}, {}); + proxyPort = proxyServer.proxyPort; + proxyHost = `http://localhost:${proxyPort}`; + const proxyWebInterfacePort = proxyServer.webServerInstance.webPort; + proxyWebInterfaceHost = `http://localhost:${proxyWebInterfacePort}`; +}); + +afterAll(() => { + return proxyServer && proxyServer.close(); +}); + +function doProxyWebSocket(url, headers = {}) { + let agent = new tunnel.httpOverHttp({ + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + + if (url.indexOf('wss') === 0) { + agent = new tunnel.httpsOverHttp({ + rejectUnauthorized: false, + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + } + + const ws = new WebSocket(url, { + agent, + rejectUnauthorized: false, + headers + }); + + return ws; +} + +['http', 'https'].forEach(protocol => { + describe.only(`${protocol} - HTTP verbs`, () => { + const assertProxyRes = (result) => { + const proxyRes = result.response; + const body = JSON.parse(result.body); + expect(proxyRes.statusCode).toBe(200); + expect(body.args).toMatchSnapshot('args'); + expect(body.data).toMatchSnapshot('data'); + return body; + }; + + it('GET', async () => { + const url = `${protocol}://httpbin.org/get`; + const getParam = { + param: 'param_value' + }; + await basicProxyRequest(proxyHost, 'GET', url, {}, getParam).then(assertProxyRes); + }); + + it('POST body and header', async () => { + const url = `${protocol}://httpbin.org/post`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/image.png')); + + const postHeaders = { + anyproxy_header: 'header_value', + }; + + const body = await basicProxyRequest(proxyHost, 'POST', url, postHeaders, {}, payloadStream).then(assertProxyRes); + expect(body.headers['Anyproxy-Header']).toBe(postHeaders.anyproxy_header); + }); + + it('PUT', async () => { + const url = `${protocol}://httpbin.org/put`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/image.png')); + await basicProxyRequest(proxyHost, 'PUT', url, {}, undefined, payloadStream).then(assertProxyRes); + }); + + it('DELETE', async () => { + const url = `${protocol}://httpbin.org/delete`; + const param = { + foo: 'bar', + }; + await basicProxyRequest(proxyHost, 'DELETE', url, {}, param).then(assertProxyRes); + }); + + it('PATCH', async () => { + const url = `${protocol}://httpbin.org/patch`; + await basicProxyRequest(proxyHost, 'PATCH', url).then(assertProxyRes); + }); + + it.only('Websocket', async () => { + const expectEcho = (ws) => { + return new Promise((resolve, reject) => { + const wsMsg = Buffer.alloc(100 * 1024, 'a').toString(); // 100kb + + ws.on('open', () => { + ws.send(wsMsg); + }); + + ws.on('message', (msg) => { + expect(msg).toBe(wsMsg); + ws.close(); + resolve(); + }); + }); + }; + + const wsUrl = `${protocol === 'https' ? 'wss' : 'ws'}://echo.websocket.org`; + const ws = doProxyWebSocket(wsUrl, {}); + await expectEcho(ws); + }); + }); +}); + +describe('status code and headers', () => { + [302, 404, 500].forEach(statusCode => { + it(`GET ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'GET', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + + it(`PUT ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'PUT', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + }); +}); + +describe('response data formats', () => { + ['brotli', 'deflate', 'gzip'].forEach(encoding => { + it(`GET ${encoding}`, async () => { + const url = `http://httpbin.org/${encoding}`; + const result = await basicProxyRequest(proxyHost, 'GET', url); + const headers = result.response.headers; + const body = JSON.parse(result.body); + expect(headers['content-encoding']).toBeUndefined(); // should be removed by anyproxy + expect(body.brotli || body.deflated || body.gzipped).toBeTruthy(); + }); + }); +}); + +describe('big files', () => { + const BIG_FILE_SIZE = 100 * 1024 * 1024 - 1; // 100 mb + const BUFFER_FILL = 'a'; + + let server; + beforeAll(() => { + server = http.createServer({}, (req, res) => { + if (/download/.test(req.url)) { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + res.write(bufferContent); + res.end(); + } else if (/upload/.test(req.url)) { + let reqPayloadSize = 0; + req.on('data', (data) => { + const bufferLength = data.length; + reqPayloadSize += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + res.statusCode = 500; + res.write('content not match'); + } + }).on('end', () => { + if (res.statusCode === 500 || reqPayloadSize !== BIG_FILE_SIZE) { + res.statusCode = 500; + } else { + res.statusCode = 200; + } + res.end(); + }); + } + }); + + server.listen(3000); + }); + + afterAll((done) => { + server && server.close(done); + }); + + it('download big file', (done) => { + let responseSizeCount = 0; + request({ + url: 'http://127.0.0.1:3000/download', + proxy: proxyHost, + }).on('data', (data) => { + const bufferLength = data.length; + responseSizeCount += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + return done(new Error('download content not match')); + } + }).on('end', () => { + if (responseSizeCount !== BIG_FILE_SIZE) { + return done(new Error('file size not match')); + } + done(); + }); + }, 120 * 1000); + + it('upload big file', (done) => { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + const req = request({ + url: 'http://127.0.0.1:3000/upload', + method: 'POST', + proxy: proxyHost, + }, (err, response, body) => { + if (err) { + return done(err); + } else if (response.statusCode !== 200) { + return done(new Error('upload failed ' + body)); + } + done(); + }); + req.write(bufferContent); + req.end(); + }, 120 * 1000); +}); + +describe('web interface', () => { + it('should be available', async () => { + await urllib.request(proxyWebInterfaceHost).then((result) => { + expect(result.status).toBe(200); + }); + }); +}); diff --git a/test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) b/test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) new file mode 100644 index 0000000..47cb354 --- /dev/null +++ b/test/basic.spec.js~78858bf... fix: replace upload fixture image.png with a smaller upload.txt (#563) @@ -0,0 +1,247 @@ + +process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'; +const path = require('path'); +const fs = require('fs'); +const urllib = require('urllib'); +const request = require('request'); +const { basicProxyRequest, proxyServerWithRule, } = require('./util.js'); +const http = require('http'); +const WebSocket = require('ws'); +const tunnel = require('tunnel'); + +let proxyServer; +let proxyPort; +let proxyHost; +let proxyWebInterfaceHost; +beforeAll(async () => { + jest.DEFAULT_TIMEOUT_INTERVAL = 20 * 1000; + proxyServer = await proxyServerWithRule({}, {}); + proxyPort = proxyServer.proxyPort; + proxyHost = `http://localhost:${proxyPort}`; + const proxyWebInterfacePort = proxyServer.webServerInstance.webPort; + proxyWebInterfaceHost = `http://localhost:${proxyWebInterfacePort}`; +}); + +afterAll(() => { + return proxyServer && proxyServer.close(); +}); + +function doProxyWebSocket(url, headers = {}) { + let agent = new tunnel.httpOverHttp({ + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + + if (url.indexOf('wss') === 0) { + agent = new tunnel.httpsOverHttp({ + rejectUnauthorized: false, + proxy: { + hostname: 'localhost', + port: proxyPort, + } + }) + } + + const ws = new WebSocket(url, { + agent, + rejectUnauthorized: false, + headers + }); + + return ws; +} + +['http', 'https'].forEach(protocol => { + describe(`${protocol} - HTTP verbs`, () => { + const assertProxyRes = (result) => { + const proxyRes = result.response; + const body = JSON.parse(result.body); + expect(proxyRes.statusCode).toBe(200); + expect(body.args).toMatchSnapshot('args'); + expect(body.data).toMatchSnapshot('data'); + return body; + }; + + it('GET', async () => { + const url = `${protocol}://httpbin.org/get`; + const getParam = { + param: 'param_value' + }; + await basicProxyRequest(proxyHost, 'GET', url, {}, getParam).then(assertProxyRes); + }); + + it('POST body and header', async () => { + const url = `${protocol}://httpbin.org/post`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/upload.txt')); + + const postHeaders = { + anyproxy_header: 'header_value', + }; + + const body = await basicProxyRequest(proxyHost, 'POST', url, postHeaders, {}, payloadStream).then(assertProxyRes); + expect(body.headers['Anyproxy-Header']).toBe(postHeaders.anyproxy_header); + }); + + it('PUT', async () => { + const url = `${protocol}://httpbin.org/put`; + const payloadStream = fs.createReadStream(path.resolve(__dirname, './fixtures/upload.txt')); + await basicProxyRequest(proxyHost, 'PUT', url, {}, undefined, payloadStream).then(assertProxyRes); + }); + + it('DELETE', async () => { + const url = `${protocol}://httpbin.org/delete`; + const param = { + foo: 'bar', + }; + await basicProxyRequest(proxyHost, 'DELETE', url, {}, param).then(assertProxyRes); + }); + + it('PATCH', async () => { + const url = `${protocol}://httpbin.org/patch`; + await basicProxyRequest(proxyHost, 'PATCH', url).then(assertProxyRes); + }); + + it('Websocket', async () => { + const expectEcho = (ws) => { + return new Promise((resolve, reject) => { + const wsMsg = Buffer.alloc(100 * 1024, 'a').toString(); // 100kb + + ws.on('open', () => { + ws.send(wsMsg); + }); + + ws.on('message', (msg) => { + expect(msg).toBe(wsMsg); + ws.close(); + resolve(); + }); + }); + }; + + const wsUrl = `${protocol === 'https' ? 'wss' : 'ws'}://echo.websocket.org`; + const ws = doProxyWebSocket(wsUrl, {}); + await expectEcho(ws); + }); + }); +}); + +describe('status code and headers', () => { + [302, 404, 500].forEach(statusCode => { + it(`GET ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'GET', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + + it(`PUT ${statusCode}`, async () => { + const status = statusCode; + const url = `http://httpbin.org/status/${status}`; + const result = await basicProxyRequest(proxyHost, 'PUT', url, {}, {}); + const proxyRes = result.response; + expect(proxyRes.statusCode).toBe(statusCode); + }); + }); +}); + +describe('response data formats', () => { + ['brotli', 'deflate', 'gzip'].forEach(encoding => { + it(`GET ${encoding}`, async () => { + const url = `http://httpbin.org/${encoding}`; + const result = await basicProxyRequest(proxyHost, 'GET', url); + const headers = result.response.headers; + const body = JSON.parse(result.body); + expect(headers['content-encoding']).toBeUndefined(); // should be removed by anyproxy + expect(body.brotli || body.deflated || body.gzipped).toBeTruthy(); + }); + }); +}); + +describe('big files', () => { + const BIG_FILE_SIZE = 100 * 1024 * 1024 - 1; // 100 mb + const BUFFER_FILL = 'a'; + + let server; + beforeAll(() => { + server = http.createServer({}, (req, res) => { + if (/download/.test(req.url)) { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + res.write(bufferContent); + res.end(); + } else if (/upload/.test(req.url)) { + let reqPayloadSize = 0; + req.on('data', (data) => { + const bufferLength = data.length; + reqPayloadSize += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + res.statusCode = 500; + res.write('content not match'); + } + }).on('end', () => { + if (res.statusCode === 500 || reqPayloadSize !== BIG_FILE_SIZE) { + res.statusCode = 500; + } else { + res.statusCode = 200; + } + res.end(); + }); + } + }); + + server.listen(3000); + }); + + afterAll((done) => { + server && server.close(done); + }); + + it('download big file', (done) => { + let responseSizeCount = 0; + request({ + url: 'http://127.0.0.1:3000/download', + proxy: proxyHost, + }).on('data', (data) => { + const bufferLength = data.length; + responseSizeCount += bufferLength; + const expectBufferContent = Buffer.alloc(bufferLength, BUFFER_FILL); + if (!expectBufferContent.equals(data)) { + return done(new Error('download content not match')); + } + }).on('end', () => { + if (responseSizeCount !== BIG_FILE_SIZE) { + return done(new Error('file size not match')); + } + done(); + }); + }, 120 * 1000); + + it('upload big file', (done) => { + const bufferContent = Buffer.alloc(BIG_FILE_SIZE, BUFFER_FILL); + const req = request({ + url: 'http://127.0.0.1:3000/upload', + method: 'POST', + proxy: proxyHost, + }, (err, response, body) => { + if (err) { + return done(err); + } else if (response.statusCode !== 200) { + return done(new Error('upload failed ' + body)); + } + done(); + }); + req.write(bufferContent); + req.end(); + }, 120 * 1000); +}); + +describe('web interface', () => { + it('should be available', async () => { + await urllib.request(proxyWebInterfaceHost).then((result) => { + expect(result.status).toBe(200); + }); + }); +}); diff --git a/test/fixtures/image.png b/test/fixtures/image.png deleted file mode 100644 index f5416aa969379d941d1e022b0dded6e4c2fe8b31..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 7181 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 diff --git a/test/fixtures/upload.txt b/test/fixtures/upload.txt new file mode 100644 index 0000000..d00491f --- /dev/null +++ b/test/fixtures/upload.txt @@ -0,0 +1 @@ +1 diff --git a/test/rule/beforeDealHttpsRequest.spec.js b/test/rule/beforeDealHttpsRequest.spec.js index d8d04e4..0bcbfed 100644 --- a/test/rule/beforeDealHttpsRequest.spec.js +++ b/test/rule/beforeDealHttpsRequest.spec.js @@ -34,11 +34,11 @@ describe('Rule beforeDealHttpsRequest', () => { }); it('Should replace the https request body', async () => { const url = 'https://httpbin.org/put'; - const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/image.png')); + const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/upload.txt')); const postHeaders = { anyproxy_header: 'header_value', }; - + await basicProxyRequest(proxyHost, 'PUT', url, postHeaders, {}, payloadStream).then((result) => { const proxyRes = result.response; const body = JSON.parse(result.body); diff --git a/test/rule/beforeSendRequest.spec.js b/test/rule/beforeSendRequest.spec.js index 965808a..52c3131 100644 --- a/test/rule/beforeSendRequest.spec.js +++ b/test/rule/beforeSendRequest.spec.js @@ -58,11 +58,11 @@ describe('Rule replaceRequestData', () => { it('should replace the request data in proxy if the assertion is true', async () => { const url = 'http://httpbin.org/post'; - const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/image.png')); + const payloadStream = fs.createReadStream(path.resolve(__dirname, '../fixtures/upload.txt')); const postHeaders = { anyproxy_header: 'header_value', }; - + await basicProxyRequest(proxyHost, 'POST', url, postHeaders, {}, payloadStream).then((result) => { const proxyRes = result.response; const body = JSON.parse(result.body); @@ -73,7 +73,7 @@ describe('Rule replaceRequestData', () => { }); it('should respond content specified in rule', async () => { - const url = 'http://httpbin.org/status/302'; + const url = 'http://httpbin.org/status/302'; await basicProxyRequest(proxyHost, 'GET', url).then((result) => { const proxyRes = result.response; const body = result.body; @@ -84,7 +84,7 @@ describe('Rule replaceRequestData', () => { }); it('should replace protocol and url', async () => { - const url = 'http://domain_not_exists.anyproxy.io/should_be_replaced'; + const url = 'http://domain_not_exists.anyproxy.io/should_be_replaced'; await basicProxyRequest(proxyHost, 'GET', url).then((result) => { const proxyRes = result.response; expect(proxyRes.statusCode).toBe(302);