Add Context, StatusPage, and related endpoints

Author: brennana

bin/codegen/ts

@@ -1,10 +1,11 @@
 #!/usr/bin/env bash
 
+INFILE=${1:-"core.raml"}
 SPECFILE=/tmp/api-specification-codegen-ts-$(date +%s).json
 
 mkdir -p dist/codegen
 
-bin/openapi3 core.raml > $SPECFILE
+bin/openapi3 $INFILE > $SPECFILE
 
 cd bin
 

bin/docs

@@ -1,3 +1,3 @@
 #!/usr/bin/env bash
 
-bin/redoc core.raml > dist/index.html
+bin/redoc context.raml > dist/index.html

bin/lib/openapi3-post-processing.js

@@ -73,9 +73,11 @@ function normalizeOpenApi3(spec) {
   return normalizeLogo(removeAnnotations(normalizeSecuritySchemes(spec)))
     .replace(/x-amf-union/g, "anyOf")
     .replace(/x-core\.tags/g, "tags")
+    .replace(/x-core\.badges/g, "x-badges")
     .replace(/x-core\.tagGroups/g, "x-tagGroups")
     .replace(/x-core\.expandable/g, "x-expandable")
-    .replace(/("x-expandable":)null/g, "$1true")
+    .replace(/x-core\.delegable/g, "x-delegable")
+    .replace(/("x-(expandable|delegable)":)null/g, "$1true")
     .replace(/x-prelude\.discriminatorJunction/g, "discriminator")
     .replace(/,"anyOf":\[{"\$ref":"[^"]+"}]/g, "")
     // FIXME: the following shouldn't be necessary, but something causes the

bin/lib/post-processing.js

@@ -232,13 +232,37 @@ function isolateCommonProperties(_resolved) {
   })
 }
 
+function expandBadges(resolved, badges) {
+  if (!badges) return
+
+  const badgeDefinitions = util.findCustomDomainProperty(resolved.encodes, "core.badges")?.extension?.members
+
+  if (!badgeDefinitions) return
+
+  const expanded = new amf.ArrayNode()
+
+  badges.extension.members.forEach(ref => {
+    const name = ref.value.value(),
+          defn = badgeDefinitions.find(m => m.properties.name.value.value() === name)
+
+    expanded.addMember(defn)
+  })
+
+  badges.withExtension(expanded)
+
+  return badges
+}
+
 function copyResourceTagsToMethods(resolved) {
   resolved.encodes.endPoints.forEach((endpoint) => {
-    var tags = endpoint.customDomainProperties.find((prop) => prop.name.value() == "core.tags")
-    if (!tags) return
+    const tags = util.findCustomDomainProperty(endpoint, "core.tags"),
+          badges = expandBadges(resolved, util.findCustomDomainProperty(endpoint, "core.badges"))
 
-    endpoint.operations
-      .forEach((operation) => operation.withCustomDomainProperties([tags].concat(operation.customDomainProperties)))
+    if (!tags && !badges) return
+
+    endpoint.operations.forEach((operation) =>
+      operation.withCustomDomainProperties([tags, badges].filter(p => p).concat(operation.customDomainProperties))
+    )
   })
 }
 
@@ -300,25 +324,29 @@ function mergeResourceSpecBindIdsToResponses(resolved) {
   })
 }
 
+function maybeMergeResourceAnnotationToResponse(response, annotation, resourceAnnotation) {
+  const responseAnnotation = util.findCustomDomainProperty(response, annotation)
+
+  if (!responseAnnotation && resourceAnnotation) {
+    response.withCustomDomainProperties([resourceAnnotation].concat(response.customDomainProperties))
+  }
+}
+
 function mergeResourceSpecFactoryAnnotationsToResponses(resolved) {
   resolved.encodes.endPoints.forEach((endPoint) => {
     var factoryStrategy = util.findCustomDomainProperty(endPoint, "specs.factoryStrategy"),
-        factoryName = util.findCustomDomainProperty(endPoint, "specs.factoryName")
+        factoryName = util.findCustomDomainProperty(endPoint, "specs.factoryName"),
+        contextualRequestBodies = util.findCustomDomainProperty(endPoint, "specs.contextualRequestBodies"),
+        baseContext = util.findCustomDomainProperty(endPoint, "specs.baseContext")
 
-    if (!factoryStrategy && !factoryName) return
+    if (!factoryStrategy && !factoryName && !contextualRequestBodies && !baseContext) return
 
     endPoint.operations.forEach((operation) => {
       operation.responses.forEach((response) => {
-        let rStrategy = util.findCustomDomainProperty(response, "specs.factoryStrategy"),
-            rName = util.findCustomDomainProperty(response, "specs.factoryName")
-
-        if (!rStrategy && factoryStrategy) {
-          response.withCustomDomainProperties([factoryStrategy].concat(response.customDomainProperties))
-        }
-
-        if (!rName && factoryName) {
-          response.withCustomDomainProperties([factoryName].concat(response.customDomainProperties))
-        }
+        maybeMergeResourceAnnotationToResponse(response, "specs.factoryStrategy", factoryStrategy)
+        maybeMergeResourceAnnotationToResponse(response, "specs.factoryName", factoryName)
+        maybeMergeResourceAnnotationToResponse(response, "specs.contextualRequestBodies", contextualRequestBodies)
+        maybeMergeResourceAnnotationToResponse(response, "specs.baseContext", baseContext)
       })
     })
   })
@@ -376,6 +404,29 @@ function moveFieldDescriptionsToProperties(resolved) {
     })
 }
 
+function applyDelegableFieldFlags(_resolved) {
+  Object.values(hoistedShapes).forEach(shape => {
+    const delegableFields = util.findCustomDomainProperty(shape, "core.delegableFields")
+
+    if (delegableFields) {
+      delegableFields.extension.members.forEach(field => {
+        const fieldName = field.value.value(),
+              property = shape.properties.find(p => p.name == fieldName)
+
+        const flag = new amf.DomainExtension()
+        flag.withName("core.delegable")
+        flag.withExtension(new amf.ScalarNode("", "http://www.w3.org/2001/XMLSchema#nil"))
+
+        property.range.withCustomDomainProperties([flag])
+      })
+
+      shape.withCustomDomainProperties(shape.customDomainProperties
+        .filter((prop) => prop.name.value() !== "core.delegableFields")
+      )
+    }
+  })
+}
+
 function copyObjectDescriptionsToTags(resolved) {
   const tags = util.findCustomDomainProperty(resolved.encodes, "core.tags")
   if (!tags) return
@@ -391,13 +442,36 @@ function copyObjectDescriptionsToTags(resolved) {
   })
 }
 
-exports.postProcess = (resolved) => {
+function extendAnnotation(name, resolved, original) {
+  debugger
+  const ext = util.findCustomDomainProperty(resolved.encodes, name),
+        orig = util.findCustomDomainProperty(original.encodes, name),
+        extension = new amf.ArrayNode()
+
+  orig.extension.members.forEach(m => extension.addMember(m))
+  ext.extension.members.forEach(m => extension.addMember(m))
+
+  ext.withExtension(extension)
+}
+
+function extendTagAnnotations(resolved, parsed) {
+  if (!parsed) return
+
+  const original = parsed.references().find(r => r.encodes?.id?.endsWith("/web-api"))
+
+  extendAnnotation("core.tags", resolved, original)
+  extendAnnotation("core.tagGroups", resolved, original)
+}
+
+exports.postProcess = (resolved, parsed) => {
+  extendTagAnnotations(resolved, parsed)
   hoistPayloadExamples(resolved)
   hoistCommonTypes(resolved)
   isolateCommonProperties(resolved)
   hoistDiscriminatorJunctions(resolved)
   copyResourceTagsToMethods(resolved)
   moveFieldDescriptionsToProperties(resolved)
+  applyDelegableFieldFlags(resolved)
   mergeResourceSpecBindIdsToResponses(resolved)
   mergeResourceSpecFactoryAnnotationsToResponses(resolved)
   copyObjectDescriptionsToTags(resolved)

bin/lib/request-spec-generator.js

@@ -2,7 +2,9 @@ const amf = require("amf-client-js")
 const util = require("./utilities")
 
 class RequestSpecGenerator {
-  constructor(resolved) {
+  constructor(resolved, tags, target) {
+    this.tags = tags
+    this.target = target || "state"
     this.resolved = resolved
     this.schemas = {}
     this.spec = undefined
@@ -18,7 +20,7 @@ class RequestSpecGenerator {
   requestBindings(operation, response, requestBodyInfo) {
     if (!this.supportsRequestBody(operation)) return []
 
-    var paramsBinding, headersBinding = 'headers.merge! "content-type" => "application/json"'
+    var paramsBinding, headersBinding = 'headers["content-type"] = "application/json"'
 
     var requestBody = response.customDomainProperties.find(d => d.name.value() == "specs.requestBody")?.extension?.value?.value(),
         attributesStrategy = this.factoryAttributesStrategy(response),
@@ -62,7 +64,7 @@ class RequestSpecGenerator {
 
     permissionLevel = permissionLevel.extension.value.value()
 
-    return `let(:api_key) { create :api_key, :${permissionLevel}, user: api_key_user }`
+    return `let(:api_key) { op_create :api_key, :${permissionLevel}, params: { user: api_key_user.id.to_s }${this.bindingContext()} }`
   }
 
   idBindings(response) {
@@ -78,7 +80,7 @@ class RequestSpecGenerator {
       if (idValue == "auto" || idValue.startsWith("auto:")) {
         var traits = idValue.split(":").slice(1),
             bindTraits = traits.length == 0 ? "" : `, ${traits.map(t => ":" + t).join(", ")}`
-        bindValue = `${factoryStrategy}(:${factoryName || model}${bindTraits}).id.to_s`
+        bindValue = `${factoryStrategy}(:${factoryName || model}${bindTraits}${this.bindingContext()}).id.to_s`
       } else {
         bindValue = `"${idValue}"`
       }
@@ -114,6 +116,7 @@ class RequestSpecGenerator {
     return `
       it "${this.testCaseDescription(requestBodyInfo)}"${this.testCaseFlags(requestBodyInfo)} do
         ${bindings.join("\n")}
+        ${this.authorizationHeaders(response)}
         ${operation.method.value()} "${this.basePath}${this.endPointPath(endPoint, idBindings)}"${this.requestOptions(operation, bindings[0])}
 
         expect(response).to have_http_status(${code})
@@ -152,6 +155,43 @@ class RequestSpecGenerator {
     }).join("\n\n");
   }
 
+  baseContextBinding(response) {
+    var baseCtx = util.findCustomDomainProperty(response, "specs.baseContext")
+
+    if (!baseCtx) return ""
+
+    return `let(:context) { ${baseCtx.extension.value.value()} }`
+  }
+
+  contextualResponseTestCases(endPoint, operation, response, code, idBindings, bodyExpectation) {
+    var ctxs = util.findCustomDomainProperty(response, "specs.contextualRequestBodies")?.extension?.members
+    if (!ctxs) return ""
+
+    return ctxs.map(ctxMember => {
+      const ctx = ctxMember.value.value()
+
+      return `
+      context "when the context is a ${ctx.replace("@", "")}" do
+        let(:context) { ${ctx} }
+
+        ${this.responseTestCase(endPoint, operation, response, code, idBindings, bodyExpectation)}
+      end
+      `
+    }).join("\n\n")
+  }
+
+  authorizationHeaders(response) {
+    const authStrategy = util.findCustomDomainProperty(response, "specs.authStrategy")?.extension?.value?.value()
+
+    if (authStrategy === "session") {
+      return `
+        headers["authorization"] = "Session"
+        headers["cookie"] = "session_token=#{api_key_user.remember_token}"
+        headers["sec-fetch-site"] = "same-origin"
+      `
+    } else return ""
+  }
+
   beforeHook(response) {
     var hook = util.findCustomDomainProperty(response, "specs.beforeHook")
 
@@ -170,13 +210,15 @@ class RequestSpecGenerator {
     var factoryName = this.factoryName(response);
 
     return Object.entries(createModels.extension.properties).map(([model, options]) => {
-      var count = options.properties.count?.value?.value() || 3,
+      var count = options.properties.count?.value?.value() ?? 3,
           traits = options.properties.traits?.value?.value()?.split(":") || [],
           traitsSection = traits.length == 0 ? "" : `, ${traits.map(t => ":" + t).join(", ")}`,
           factoryOptions = Object.entries(options.properties.options?.properties || {}),
           factoryOptionsSection = factoryOptions.length == 0 ? "" : `, ${factoryOptions.map(([opt, val]) => `${opt}: ${val.value.value()}`).join(", ")}`
 
-      return `before { ${strategy}_list :${factoryName || model}, ${count}${traitsSection}${factoryOptionsSection} }`
+      if (count <= 0) return ""
+
+      return `before { ${strategy}_list :${factoryName || model}, ${count}${traitsSection}${factoryOptionsSection}${this.bindingContext()} }`
     }).join("\n")
   }
 
@@ -202,24 +244,28 @@ class RequestSpecGenerator {
       context "${code} (${response.description.value().trim().replace(/\.$/, "")})" do
         ${this.apiKeyBinding(response)}
         ${idBindings}
+        ${this.baseContextBinding(response)}
 
         ${this.beforeHook(response)}
         ${this.createModelsHook(response)}
 
         ${this.responseTestCase(endPoint, operation, response, code, idBindings, bodyExpectation)}
         ${this.exhaustiveResponseTestCases(endPoint, operation, response, code, idBindings, bodyExpectation)}
+        ${this.contextualResponseTestCases(endPoint, operation, response, code, idBindings, bodyExpectation)}
       end
       `
     }, "").join("\n\n")
   }
 
   operations() {
     return this.resolved.encodes.endPoints.map((endPoint) => {
-      const resourceTag = util.findCustomDomainProperty(endPoint, "core.tags")?.extension?.members?.[0]?.value?.value() || ""
+      const resourceTags = util.findCustomDomainProperty(endPoint, "core.tags")?.extension?.members || []
+
+      if (!this.isTagEnabled(resourceTags)) return ""
 
       return endPoint.operations.map((operation) => {
         return `
-        describe "${operation.method.value().toUpperCase()} ${this.basePath}${endPoint.path.value()}"${resourceTag && `, resource: "${resourceTag}"`} do
+        describe "${operation.method.value().toUpperCase()} ${this.basePath}${endPoint.path.value()}"${(resourceTags[0] ?? "") && `, resource: "${resourceTags[0].value.value()}"`} do
           ${this.responses(endPoint, operation)}
         end
         `
@@ -232,16 +278,44 @@ class RequestSpecGenerator {
     require "rails_helper"
 
     RSpec.describe "${this.basePath} (version: latest)", :timeline_simulation do
-      before(:example) { DatabaseCleaner.clean }
-      let(:api_key_user) { create :user, :admin }
-      let(:api_key) { create :api_key, :write, user: api_key_user }
+      before(${this.target === "website" ? ":context" : ":example"}) { DatabaseCleaner.clean }
+      ${this.rootBeforeHook()}
+
+      let(:api_key_user) { op_create :user, :admin${this.bindingContext()} }
+      let(:api_key) { op_create :api_key, :write, params: { user: api_key_user.id.to_s }${this.bindingContext()} }
+
       let(:headers) { { accept: "application/hal+json;variant=compact", authorization: "Bearer #{api_key.token}" } }
 
+      ${this.rootContextBindings()}
+
       ${content}
     end
     `
   }
 
+  rootBeforeHook() {
+    if (this.target !== "website") return ""
+
+    return `
+    before(:context) do
+      @client = VCR.use_cassette("op_create/client") { op_create :client }
+      @primary_status_page = @client.status_pages.first
+      @secondary_status_page = op_create :status_page, client: @client
+    end
+    `
+  }
+
+  rootContextBindings() {
+    if (this.target !== "website") return ""
+
+    return `
+    let(:context) { @primary_status_page }
+    let(:context_host) { "#{context.domain}.hund.localhost" }
+
+    before { host! context_host }
+    `
+  }
+
   schemaId(schema) {
     return schema.id
       .split("#")[1]
@@ -250,6 +324,18 @@ class RequestSpecGenerator {
       .replace(/%/g, "_")
   }
 
+  isTagEnabled(tags) {
+    if (!this.tags) return true
+
+    return tags.some(tag => this.tags.includes(tag.value.value()))
+  }
+
+  bindingContext() {
+    if (this.target === "website") return ", client: @client"
+
+    return ""
+  }
+
   supportsRequestBody(operation) {
     return ["post", "put", "patch", "delete"].includes(operation.method.value())
   }