Simlet Parameters

SomeParameterName:
  is: parameter

  # One of the 'from' sources below

  # The HTTP method: GET, POST, PUT, etc.
  from: httpMethod

  # The whole URI
  from: uri

  # The scheme - http/https - if present in the URI
  from: uriScheme

  # The path part of the URI only
  from: uriPath

  from: uriPathPattern
  pattern: "/uri/path/{pattern}/here"

  # The user info (userid and/or password) part of the URI
  from: uriUserInfo

  # The host part of the URI
  from: uriHost

  # The port number part of the URI
  from: uriPort

  # Query String Parameters
  # A map of all Query String Parameters. Each map entry is keyed by the query
  # string parameter name and the value is a list with zero or more elements
  from: uriQueryParameters

  # A Query String Parameter
  # There can be more than one Query String Parameter with the same name.
  # This parameter will have them all in a list of items accessible by index.
  from: uriQueryParameter
  named: "query-string-parameter-name"

  # The fragment (the part after '#') in the URI
  from: uriFragment

  # The HTTP version the request uses (e.g. HTTP/1.1)
  from: httpVersion

ParameterName:
  is: parameter
  from: header
  named: "name-of-the-header-field"

SessionIDParm:
  is: parameter
  from: cookie
  named: "SessionID"

LanguageParm:
  is: parameter
  from: cookie
  named: "lang"
  default: "en-US"

ParameterName:
  is: parameter
  from: constant
  value: <some-constant-value>

PaymentID:
  is: parameter
  from: uuid

DateTimeNow:
  is: parameter
  from: dateTime

# Choose a parameter name
<Parameter-Name>:
  is: parameter
  from: file
  # File type is a text file (the default) or binary (e.g. an image)
  type: text | binary
  # Option to configure the charset when file type is text. Defaults to UTF-8
  charset: UTF-8
  # See below how to configure the file source
  file: ...
  # Whether to cache the file content in memory. Default is true.
  # Notice that when using large number of files and/or big files,
  # you may have to adjust API Simulator's startup memory settings
  # or to disable file caching for some parameters from file
  cacheFile: true | false
  # `isSnapshot` is always false so the parameter gets evaluated every time it is
  # used in a response but the file content can still be retrieved from the cache

<Parameter-Name>:
  is: parameter
  from: file
  ...
  file: <full-file-specification>

# OR
<Parameter-Name>:
  is: parameter
  from: file
  ...
  file:
    path: <path/to/file>
    name: <file-name>

# OR
<Parameter-Name>:
  is: parameter
  from: file
  ...
  file:
    # Groovy script. End it with a `return` statement
    eval: .... return <full-file-specification>

ResponseBody1:
  is: parameter
  from: file
  file: ${sim.path}/product-${ProductID}.json

# Equivalent to ResponseBody1
ResponseBody2:
  is: parameter
  from: file
  file:
    path: ${sim.path}
    name: product-${ProductID}.json

# Equivalent to ResponseBody2
ResponseBody3:
  is: parameter
  from: file
  file:
    eval: return ${sim.path} + '/' + 'product-' + ${ProductID} + '.json'

# Equivalent to ResponseBody3
ResponseBody4:
  is: parameter
  from: file
  file:
    eval: return _sim.path + '/' + 'product-' + ProductID + '.json'

FaviconFileParm:
  is: parameter
  from: file
  type: binary
  file: ${sim.path}/favicon-16x16.png

ProductID:
  is: parameter
  from: uriPathPattern
  pattern: /products/product/{id}

request:
- method: GET
- where: parameter
  named: ProductID
  exists: true

ResponseBody:
  is: parameter
  from: file
  file:
    path: ${simlets.path}
    name: product-${ProductID}.json

response:
  from: template
  headers:
  - "Content-Type: application/json; charset=UTF-8"
  body: ${ResponseBody}

ProductID:
  is: parameter
  from: uriPathPattern
  pattern: /products/product/{id}

request:
- method: GET
- where: parameter
  named: ProductID
  exists: true

ProductFileSpec:
  is: parameter
  from: script
  expression: `
fname = 'product-' + ProductID + '.json'
return new File(${sim.path}, fname)
`

ResponseBody:
  is: parameter
  from: file
  file:
    eval: return ProductFileSpec.toString()

IsProductFound:
  is: parameter
  from: script
  expression: return ProductFileSpec.exists()

response:
  from: template
  status: '${ IsProductFound ? 200 : 404 }'
  headers:
  - "Content-Type: application/json; charset=UTF-8"
  # Parameters referenced by name in scriptlet expressions, like
  # ProductID below, or placeholders in the body do get evaluated
  body: `
  <%
     if (IsProductFound) {
       write ResponseBody
     }
     else {
       write '{ "error": "Product with ID=' + ProductID + ' not found" }'
     }
  %>
`

<ParameterName>:
  is: parameter
  from: script
  expression: <Groovy script that must return a value>

<ParameterName>:
  is: parameter
  from: template
  template: Simula
  text: <template-text-here>

TodaysTide:
  is: parameter
  from: template
  text: "The tide is <% if (TideLevel < 20) { write 'low' } else { write 'high' } %> today"

response:
  from: template
  headers:
  - "Content-Type: application/text"
  body: ${TodaysTide}

TodaysTide:
  is: parameter
  from: template
  text: "The tide is <% if (TideLevel < 20) { %>low<% } else { %>high<% } %> today"

TodaysTide:
  is: parameter
  from: template
  text: "The tide is ${ TideLevel < 20 ? 'low' : 'high' } today"

CurrentDateTime:
  is: parameter
  from: dateTime

# Let's read the definition out loud:
# This 'ExpireDateTime' parameter value comes from another parameter named
# 'CurrentDateTime' evaluated by adding 86400 seconds to its value.
ExpireDateTime:
  is: parameter
  from: parameter
  named: CurrentDateTime
  eval: return _ + (86400 * 1000L)

# The parameter's value is the whole list
# with the order of elements preserved
LastNameList:
  is: parameter
  from: list
  list: [ "Smith", "Johnson" ]

LastNameList:
  is: parameter
  from: list
  list:
  - "Smith"
  - "Johnson"

<Parameter-Name>:
  is: parameter
  from: list
  file: <file-spec>
    # OR
    path: <file-path>
    name: <file-name>
    # OR
    # Simple Groovy script (e.g. no method or function definitions). End with `return` statement
    eval: ... return <full-file-specification>
  # Optional. The default value is `true`
  cacheFile: true | false
  # Option to configure the charset when file type is text. Defaults to UTF-8
  charset: UTF-8

ParameterName:
  is: parameter
  from: number
  range:
    min: <minimum-value>
    max: <maximum-value>

OrderDate:
  from: dateTime
  range:
    # At least one of the 'min' or 'max' range boundaries is required.
    # Missing range boundary is assumed to be the current data and time,
    # possibly causing switching the values to assure 'min' < 'max'.
    min:    "2018-01-01 00:00:00 UTC"
    max:    "2018-01-31 11:59:59 UTC"
    # The same format applies to both 'min' and 'max'
    format: "yyyy-MM-dd HH:mm:ss z"

OrderDate:
  from: dateTime
  range:
    # Randomly generates a new datetime value that is in the range of
    # [ "now" + min, "now" + max]
    # Negative values for 'min' or max' will be subtracted from "now".
    # At least one of the 'min' or 'max' range boundaries is required.
    # Missing range boundary is assumed to have value of 0 (zero),
    # possibly causing switching the values to assure 'min' < 'max'.
    min: -60
    max: -30
    # The same time unit applies to both 'min' and 'max'
    timeUnit: days

PaymentNumber:
  is: parameter
  from: token
  pattern: "PAY-[0-9A-Z]{25}"

# Parameter for a single element randomly picked from the list
RegionAZ:
  is: parameter
  from: list
  list:
  - "us-central1-a"
  - "us-central1-b"
  - "us-central1-c"
  - "us-central1-f"
  # The same as 'pick: 1'
  pick: any

# The parameter is a list containing all elements randomly reordered!
AvailableZones:
  is: parameter
  from: list
  list:
  - "us-central1-a"
  - "us-central1-b"
  - "us-central1-c"
  - "us-central1-f"
  # The same as 'pick: 4' (e.g. the total number of list items)
  pick: all

# The parameter is a sub-list containing 2 randomly picked elements
FirstNameList:
  is: parameter
  from: list
  list: [ "Anna", "Bill", "Mark", "Sofia" ]
  pick: 2

FirstName:
  is: parameter
  from: list
  file: ${sim.path}/first-names.txt
  pick: 1

LastName:
  is: parameter
  from: list
  file:
    path: ${sim.path}
    name: last-names.txt
  pick: 1

SimletCounter:
  is: parameter
  from: counter
  scope: simlet

ProductID:
  is: parameter
  from: UriPathPattern
  pattern: "/v1.1/product/{productID}/**"

ProductColor:
  is: parameter
  from: UriPathPattern
  pattern: "/v1.1/product/*/{color}/*"

ProductSize:
  is: parameter
  from: UriPathPattern
  pattern: "/v1.1/product/*/*/{size}"

ProductData:
  is: parameter
  from: sql

  connection:
    # Currently, pooled connections are not supported
    uses: driver

    # Driver's fully-qualified class name
    driver: "org.h2.Driver"

    # Using "/./" seems to be required for H2
    url: "jdbc:h2:${simlets.path}/./product-data"

    # Credentials must be provided if the database is password-protected
    username:
    password:

    # Optional other driver-specific name/value properties
    props:
      propName: propValue

  # Parameterized SQL query
  query: `
SELECT p.*, c.*
FROM PRODUCT p, PRICE c
WHERE p.SKU = c.SKU
  AND p.ProductID=?
  AND p.Color=?
  AND p.Size=?
`

  # pick: first | all
  # The parameter will contain the "first" matching row or "all" of them
  # as a single object or a list, respectively. No matches results in null.
  # For backward compatibility, it defaults to "first". Added in v1.12
  pick: first

  # Ordered list of parameters to use in querying the SQL database.
  # A parameter may appear more than once in the list.
  # The parameter names don't have to match the database column names
  parms:
  - ProductID
  - ProductColor
  - ProductSize


request:
- method: GET
- uriPathPattern: "/v1.1/product/{id}/{color}/{size}"
- where: parameter
  named: ProductData
  exists: true


response:
  from: template
  template: Simula
  status: 200
  headers:
  - "Content-Type: application/json; charset=UTF-8"
  body: `
{
  "product": {
    "id": "${ProductData['ProductID']}",
    "sku": "${ProductData['SKU']}",
    "name": "${ProductData['Name']}",
    "category": "${ProductData['Category']}",
    "subCategory": "${ProductData['Subcategory']}",
    "color": "${ProductData['Color']}",
    "size": "${ProductData['Size']}",
    "orig_price": ${ProductData['Original_Price']},
    "sale_price": ${ProductData['Sale_Price']}
  }
}
`

ProductID:
  is: parameter
  from: uriPathPattern
  pattern: "/v1.1/product/{productID}/*"

ProductColor:
  is: parameter
  from: uriPathPattern
  pattern: "/v1.1/product/*/{color}"


ProductData:
  is: parameter
  from: sql

  connection:
    # Currently, pooled connections are not supported
    uses: driver # pool

    # Driver's fully-qualified class name
    driver: "org.h2.Driver"

    # Using "/./" seems to be required for H2
    url: "jdbc:h2:${simlets.path}/./product-data"

    # Credentials must be provided if the database is password-protected
    username:
    password:

    # Optional other driver-specific name/value properties
    props:
      propName: propValue

  # Parameterized SQL query
  query: `
SELECT p.*, c.*
FROM PRODUCT p, PRICE c
WHERE p.SKU = c.SKU
  AND p.ProductID=?
  AND p.Color=?
ORDER BY p.SKU
`

  # pick: first | all
  # The parameter will contain the "first" matching row or "all" of them
  # as a single object or a list, respectively. No matches results in null.
  # For backward compatibility, it defaults to "first". Added in v1.12
  pick: all

  # Ordered list of parameters to use in querying the SQL database.
  # A parameter may appear more than once in the list.
  # The parameter names need not to match the database column names
  parms:
  - ProductID
  - ProductColor


request:
- method: GET

- where: uriPathPattern
  matches: "/v1.1/product/{id}/{color}"

- where: parameter
  named: ProductData
  exists: true


response:
  from: template
  template: Simula
  status: 200
  headers:
  - "Content-Type: application/json; charset=UTF-8"
  body: `
{
  "products": [<%
count = 0;
for (Product : ProductData) {
  if (count++ > 0) { write "," } %>
    {
      "id": "${ Product['ProductID'] }",
      "sku": "${ Product['SKU'] }",
      "name": "${ jsonEncode( Product['Name'] ) }",
      "category": "${ Product['Category'] }",
      "subCategory": "${ Product['Subcategory'] }",
      "color": "${ Product['Color'] }",
      "size": "${ Product['Size'] }",
      "orig_price": ${ Product['Original_Price'] },
      "sale_price": ${ Product['Sale_Price'] }
    }<%
} %>
  ]
}
`