@mbtest/mountebank 2.9.2-beta.9050

package/src/views/docs/api/predicates/and.ejs

@@ -0,0 +1,62 @@
+<p>The <code>and</code> predicate matches if all of its sub-predicates match.</p>
+
+<testScenario name='tcp and example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4554,
+  "protocol": "tcp",
+  "mode": "text",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "data": "matches" } }],
+      "predicates": [
+        {
+          "and": [
+            { "startsWith": { "data": "start" } },
+            { "endsWith": { "data": "end\n" } },
+            { "contains": { "data": "middle" } }
+          ]
+        }
+      ]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>The first request matches all sub-predicates, triggering the stub response:</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight1'>start middle end</strong>' | nc localhost 4554</code></pre>
+
+        <assertResponse>
+<pre><code><strong class='highlight1'>matches</strong></code></pre>
+        </assertResponse>
+    </step>
+
+    <p>The stub matches two of the three sub-predicates, which is not enough to match
+the <code>and</code> predicate.</p>
+
+<p>The stub does not match none of the sub-predicates match...</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight1'>start end</strong>' | nc localhost 4554</code></pre>
+
+<p>No response is sent.</p>
+
+        <assertResponse>
+<pre><code>
+</code></pre>
+        </assertResponse>
+    </step>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4554 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>

package/src/views/docs/api/predicates/contains.ejs

@@ -0,0 +1,64 @@
+<p>Let's create a binary TCP imposter with multiple stubs:</p>
+
+<testScenario name='tcp contains example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4547,
+  "protocol": "tcp",
+  "mode": "binary",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "data": "Zmlyc3QgcmVzcG9uc2U=" } }],
+      "predicates": [{ "contains": { "data": "AgM=" } }]
+    }</strong>,<strong class='highlight2'>
+    {
+      "responses": [{ "is": { "data": "c2Vjb25kIHJlc3BvbnNl" } }],
+      "predicates": [{ "contains": { "data": "Bwg=" } }]
+    }</strong>,<strong class='highlight3'>
+    {
+      "responses": [{ "is": { "data": "dGhpcmQgcmVzcG9uc2U=" } }],
+      "predicates": [{ "contains": { "data": "Bwg=" } }]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>We're sending a base64-encoded version of four bytes: 0x1, 0x2, 0x3,
+and 0x4.  Our first predicate is a base64 encoded version of 0x2 and 0x3.
+The response is a base64-encoded version of the string "first response":</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight1'>AQIDBA==</strong>' | base64 --decode | nc localhost 4547</code></pre>
+
+        <assertResponse>
+<pre><code><strong class='highlight1'>first response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>Next we'll send 0x5, 0x6, 0x7, and 0x8, matching on a predicate
+encoding 0x7 and 0x8:</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight2'>BQYHCA==</strong>' | base64 --decode | nc localhost 4547</code></pre>
+
+        <assertResponse>
+<pre><code><strong class='highlight2'>second response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The third stub will never run, since it matches the same requests as the
+second stub.  mountebank always chooses the first stub that matches based on
+the order you add them to the <code>stubs</code> array when creating the
+imposter.</p>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4547 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>

package/src/views/docs/api/predicates/deepEquals.ejs

@@ -0,0 +1,114 @@
+<p>Let's create an HTTP imposter with multiple stubs:</p>
+
+<testScenario name='http deepEquals example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4556,
+  "protocol": "http",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "body": "first" } }],
+      "predicates": [{
+        "deepEquals": {
+          "query": {}
+        }
+      }]
+    }</strong>,<strong class='highlight2'>
+    {
+      "responses": [{ "is": { "body": "second" } }],
+      "predicates": [{
+        "deepEquals": {
+          "query": {
+            "first": "1"
+          }
+        }
+      }]
+    }</strong>,<strong class='highlight3'>
+    {
+      "responses": [{ "is": { "body": "third" } }],
+      "predicates": [{
+        "deepEquals": {
+          "query": {
+            "first": "1",
+            "second": "2"
+          }
+        }
+      }]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>The first predicate matches only a request without a querystring.</p>
+
+    <step type='http'>
+<pre><code>GET /test HTTP/1.1
+Host: localhost:4556</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+
+<strong class='highlight1'>first</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The second stub matches only if the exact querystring is sent.</p>
+
+    <step type='http'>
+<pre><code>GET /test?<strong class='highlight2'>First=1</strong> HTTP/1.1
+Host: localhost:4556</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+
+<strong class='highlight2'>second</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The third stub matches only if both query keys are sent.</p>
+
+    <step type='http'>
+<pre><code>GET /test?<strong class='highlight3'>Second=2&amp;First=1</strong> HTTP/1.1
+Host: localhost:4556</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+
+<strong class='highlight3'>third</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>Any additional query parameters will trigger the default HTTP response.</p>
+
+    <step type='http'>
+<pre><code>GET /test?Second=2&amp;First=1&amp;Third=3 HTTP/1.1
+Host: localhost:4556</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked</code></pre>
+        </assertResponse>
+    </step>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4556 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>

package/src/views/docs/api/predicates/endsWith.ejs

@@ -0,0 +1,66 @@
+<p>Let's create a binary-based imposter with multiple stubs:</p>
+
+<testScenario name='tcp endsWith example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4549,
+  "protocol": "tcp",
+  "mode": "binary",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "data": "Zmlyc3QgcmVzcG9uc2U=" } }],
+      "predicates": [{ "endsWith": { "data": "AwQ=" } }]
+    }</strong>,<strong class='highlight2'>
+    {
+      "responses": [{ "is": { "data": "c2Vjb25kIHJlc3BvbnNl" } }],
+      "predicates": [{ "endsWith": { "data": "BQY=" } }]
+    }</strong>,<strong class='highlight3'>
+    {
+      "responses": [{ "is": { "data": "dGhpcmQgcmVzcG9uc2U=" } }],
+      "predicates": [{ "endsWith": { "data": "BQY=" } }]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>We'll use the command line <code>base64</code> tool to decode the
+request to binary before sending to the imposter.  We're sending a
+base64-encoded version of four bytes: 0x1, 0x2, 0x3, and 0x4.  Our
+first predicate is a base64 encoded version of 0x3 and 0x4.  The
+response is a base64-encoded version of the string "first response":</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight1'>AQIDBA==</strong>' | base64 --decode | nc localhost 4549</code></pre>
+
+        <assertResponse>
+<pre><code><strong class='highlight1'>first response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>Next we'll send 0x1, 0x2, 0x4, 0x5, and 0x6, matching on a predicate
+encoding 0x5 and 0x6:</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight2'>AQIDBAUG</strong>' | base64 --decode | nc localhost 4549</code></pre>
+
+        <assertResponse>
+<pre><code><strong class='highlight2'>second response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The third stub will never run, since it matches the same requests as the
+second stub.  mountebank always chooses the first stub that matches based on
+the order you add them to the <code>stubs</code> array when creating the
+imposter.</p>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4549 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>

package/src/views/docs/api/predicates/equals.ejs

@@ -0,0 +1,125 @@
+<p>Let's create an HTTP imposter with multiple stubs:</p>
+
+<testScenario name='http equals example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4545,
+  "protocol": "http",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "statusCode": 400 } }],
+      "predicates": [
+        {
+          "equals": {
+            "method": "POST",
+            "path": "/test",
+            "query": {
+              "first": "1",
+              "second": "2"
+            },
+            "headers": {
+              "Accept": "text/plain"
+            }
+          }
+        },
+        {
+          "equals": { "body": "hello, world" },
+          "caseSensitive": true,
+          "except": "!$"
+        }
+      ]
+    }</strong>,<strong class='highlight2'>
+    {
+      "responses": [{ "is": { "statusCode": 406 } }],
+      "predicates": [{ "equals": { "headers": { "Accept": "application/xml" } } }]
+    }</strong>,<strong class='highlight3'>
+    {
+      "responses": [{ "is": { "statusCode": 405 } }],
+      "predicates": [{ "equals": { "method": "PUT" } }]
+    }</strong>,<strong class='highlight4'>
+    {
+      "responses": [{ "is": { "statusCode": 500 } }],
+      "predicates": [{ "equals": { "method": "PUT" } }]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>The first predicate is the most complex, and the request has to match all of the
+specified request fields.  We have the option of putting multiple fields under one
+<code>equals</code> predicate or splitting each one into a separate predicate in the
+array.  In this example, all of the ones that share the default predicate parameters
+are together.  For those, neither the case of the keys nor the values will affect the
+outcome.  The <code>body</code> predicate is treated separately.  The text will be
+compared in a case-sensitive manner, after stripping away the regular expression
+<code>!$</code> (an exclamation mark anchored to the end of the string).<p>
+
+<p>The order of the query parameters and header fields does not matter.</p>
+
+    <step type='http'>
+<pre><code><strong class='highlight1'>POST /test?Second=2&amp;First=1</strong> HTTP/1.1
+Host: localhost:4545
+<strong class='highlight1'>accept: text/plain</strong>
+
+<strong class='highlight1'>hello, world!</strong></code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 <strong class='highlight1'>400</strong> Bad Request
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked</code></pre>
+        </assertResponse>
+    </step>
+
+<p>The second stub matches if the header changes.</p>
+
+    <step type='http'>
+<pre><code>POST /test?Second=2&amp;First=1 HTTP/1.1
+Host: localhost:4545
+<strong class='highlight2'>Accept: application/xml</strong>
+
+"hello, world!"</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 <strong class='highlight2'>406</strong> Not Acceptable
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked</code></pre>
+        </assertResponse>
+    </step>
+
+<p>The third stub matches on a <code>PUT</code>.</p>
+
+    <step type='http'>
+<pre><code><strong class='highlight3'>PUT</strong> /test?Second=2&amp;First=1 HTTP/1.1
+Host: localhost:4545
+Accept: application/json
+
+"hello, world!"</code></pre>
+
+        <assertResponse>
+<pre><code>
+HTTP/1.1 <strong class='highlight3'>405</strong> Method Not Allowed
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+</code></pre>
+        </assertResponse>
+    </step>
+
+<p>The fourth stub will never run, since it matches the same requests as the
+third stub.  mountebank always chooses the first stub that matches based on
+the order you add them to the <code>stubs</code> array when creating the
+imposter.</p>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4545 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>

package/src/views/docs/api/predicates/exists.ejs

@@ -0,0 +1,118 @@
+<p>The <code>exists</code> predicate is primarily for object data types, like
+HTTP headers and query parameters.  It works on string fields by simply returning
+<code>true</code> if the <code>exists</code> value is <code>true</code> and the
+string if non-empty.  Setting the <code>exists</code> value to <code>false</code>
+inverts the meaning.</p>
+
+<testScenario name='http exists example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4551,
+  "protocol": "http",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "body": "first response" } }],
+      "predicates": [
+        {
+          "exists": {
+            "query": {
+              "q": true,
+              "search": false
+            },
+            "headers": {
+              "Accept": true,
+              "X-Rate-Limit": false
+            }
+          }
+        }
+      ]
+    }</strong>,<strong class='highlight2'>
+    {
+      "responses": [{ "is": { "body": "second response" } }],
+      "predicates": [
+        {
+          "exists": {
+            "method": true,
+            "body": false
+          }
+        }
+      ]
+    }</strong>,<strong class='highlight3'>
+    {
+      "responses": [{ "is": { "body": "third response" } }],
+      "predicates": [
+        {
+          "exists": { "body": true }
+        }
+      ]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>The first stub matches if the querystring includes <code>q</code>, but not if it
+includes <code>search</code>, and if the headers include <code>Accept</code>,
+but not if they include <code>X-Rate-Limit</code>.</p>
+
+    <step type='http'>
+<pre><code>GET /?<strong class='highlight1'>q</strong>=mountebank HTTP/1.1
+Host: localhost:4551
+<strong class='highlight1'>Accept</strong>: text/plain</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+
+<strong class='highlight1'>first response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The second stub matches if the request <code>method</code> is a
+non-empty string (always <code>true</code>), and if the <code>body</code>
+is empty.</p>
+
+    <step type='http'>
+<pre><code>GET / HTTP/1.1
+Host: localhost:4551</code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+
+<strong class='highlight2'>second response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The last stub matches if the <code>body</code> is non-empty:</p>
+
+    <step type='http'>
+<pre><code>POST / HTTP/1.1
+Host: localhost:4551
+
+<strong class='highlight3'>non-empty body</strong></code></pre>
+
+        <assertResponse>
+<pre><code>HTTP/1.1 200 OK
+Connection: close
+Date: <volatile>Thu, 09 Jan 2014 02:30:31 GMT</volatile>
+Transfer-Encoding: chunked
+
+<strong class='highlight1'>third response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4551 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>

package/src/views/docs/api/predicates/inject.ejs

@@ -0,0 +1,67 @@
+<p>The <code>inject</code> predicate allows you to inject JavaScript to determine if
+the predicate should match or not.  The JavaScript should be a function that accepts
+the request object (and optionally a logger)  and returns true or false.
+See the <a href='/docs/api/injection'>injection page</a> for details.</p>
+
+<p>The execution will have access to a node.js environment.  The following example uses
+node's <code>Buffer</code> object to decode base64 to a byte array.</p>
+
+<testScenario name='tcp inject example'>
+    <step type='http'>
+<pre><code>POST /imposters HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json
+Content-Type: application/json
+
+{
+  "port": 4555,
+  "protocol": "tcp",
+  "mode": "binary",
+  "stubs": [<strong class='highlight1'>
+    {
+      "responses": [{ "is": { "data": "Zmlyc3QgcmVzcG9uc2U=" } }],
+      "predicates": [{
+        "inject": "function (request, logger) { logger.info('Inside injection'); return Buffer.from(request.data, 'base64')[2] &gt; 100; }"
+      }]
+    }</strong>,<strong class='highlight2'>
+    {
+      "responses": [{ "is": { "data": "c2Vjb25kIHJlc3BvbnNl" } }],
+      "predicates": [{
+        "inject": "request => { return Buffer.from(request.data, 'base64')[2] &lt;= 100; }"
+      }]
+    }</strong>
+  ]
+}</code></pre>
+    </step>
+
+<p>The first stub matches if the third byte is greater than 100.  The request we're
+sending is an encoding <code>[99, 100, 101]:</code></p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight1'>Y2Rl</strong>' | base64 --decode | nc localhost 4555</code></pre>
+
+        <assertResponse>
+<pre><code><strong class='highlight1'>first response</strong></code></pre>
+        </assertResponse>
+    </step>
+
+<p>The logs will also show the injected log output.  The second predicate has to
+match a request originating from localhost with the third byte less than or equal
+to 100.  We're sending <code>[98, 99, 100]</code>:</p>
+
+    <step type='exec'>
+<pre><code>echo '<strong class='highlight1'>YmNk</strong>' | base64 --decode | nc localhost 4555</code></pre>
+
+<p>...giving the response:</p>
+
+        <assertResponse>
+<pre><code>second response</code></pre>
+        </assertResponse>
+    </step>
+
+    <step type='http'>
+<code class='hidden'>DELETE /imposters/4555 HTTP/1.1
+Host: localhost:<%= port %>
+Accept: application/json</code>
+    </step>
+</testScenario>