@datapith/cdk4j-diagram 0.4.1

package/resources/IconMap.js

@@ -0,0 +1,330 @@
+const icons = {
+  "AWS::Serverless::Function": {
+    icon: "mxgraph.aws4.lambda",
+    serviceType: "compute",
+  },
+  "AWS::Serverless::SimpleTable": {
+    icon: "mxgraph.aws4.dynamodb",
+    serviceType: "database",
+  },
+  "AWS::Serverless::Api": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::Serverless::HttpApi": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::Serverless::StateMachine": {
+    icon: "mxgraph.aws4.step_functions",
+    serviceType: "applicationintegration",
+  },
+  "AWS::Lambda::Permission": {
+    icon: "mxgraph.aws4.policy",
+    serviceType: "securityidentitycomplicance",
+  },
+  "AWS::IAM::Role": {
+    icon: "mxgraph.aws4.role",
+    serviceType: "securityidentitycomplicance",
+  },
+  "AWS::SSM::Parameter": {
+    icon: "mxgraph.aws4.parameter_store",
+    serviceType: "managementgovernance",
+  },
+  "AWS::Logs::LogGroup": {
+    icon: "mxgraph.aws4.cloudwatch",
+    serviceType: "managementgovernance",
+  },
+  "AWS::EC2::Route": {
+    icon: "mxgraph.aws4.route_table",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::EC2::RouteTable": {
+    icon: "mxgraph.aws4.route_table",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::EC2::SubnetRouteTableAssociation": {
+    icon: "mxgraph.aws4.route_table",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::EC2::VPC": {
+    icon: "mxgraph.aws4.vpc",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::EC2::NatGateway": {
+    icon: "mxgraph.aws4.nat_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::EC2::EIP": {
+    icon: "mxgraph.aws4.elastic_ip_address",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::RestApi": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::Method": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::Deployment": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::Resource": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::Stage": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::Account": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGateway::Account": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::WAF::WebACL": {
+    icon: "mxgraph.aws4.waf",
+    serviceType: "securityidentitycomplicance",
+  },
+  "AWS::WAF::WebACLAssociation": {
+    icon: "mxgraph.aws4.waf",
+    serviceType: "securityidentitycomplicance",
+  },
+  "AWS::WAFv2::WebACL": {
+    icon: "mxgraph.aws4.waf",
+    serviceType: "securityidentitycomplicance",
+  },
+  "AWS::WAFv2::WebACLAssociation": {
+    icon: "mxgraph.aws4.waf",
+    serviceType: "securityidentitycomplicance",
+  },
+  "AWS::ApiGatewayV2::Api": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::ApiGatewayManagedOverrides": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::ApiMapping": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::Authorizer": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::Deployment": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::DomainName": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::Integration": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::IntegrationResponse": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::Model": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::Route": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::RouteResponse": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::Stage": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+  "AWS::ApiGatewayV2::VpcLink": {
+    icon: "mxgraph.aws4.api_gateway",
+    serviceType: "networkingcontentdelivery",
+  },
+};
+
+const colors = {
+  analytics: {
+    gradientColor: "#945DF2",
+    fillColor: "#5A30B5",
+  },
+  applicationintegration: {
+    fillColor: "#BC1356",
+    gradientColor: "#F34482",
+  },
+  blockchain: {
+    fillColor: "#D05C17",
+    gradientColor: "#F78E04",
+  },
+  managementgovernance: {
+    fillColor: "#BC1356",
+    gradientColor: "#F34482",
+  },
+  compute: {
+    fillColor: "#D05C17",
+    gradientColor: "#F78E04",
+  },
+  containers: {
+    fillColor: "#D05C17",
+    gradientColor: "#F78E04",
+  },
+  database: {
+    fillColor: "#3334B9",
+    gradientColor: "#4D72F3",
+  },
+  networkingcontentdelivery: {
+    fillColor: "#5A30B5",
+    gradientColor: "#945DF2",
+  },
+  securityidentitycomplicance: {
+    fillColor: "#C7131F",
+    gradientColor: "#F54749",
+  },
+  storage: {
+    fillColor: "#277116",
+    gradientColor: "#60A337",
+  },
+};
+
+const serviceTypeMap = {
+  Athena: "analytics",
+  CloudSearch: "analytics",
+  ElasticsearchService: "analytics",
+  EMR: "analytics",
+  Kinesis: "analytics",
+  MSK: "analytics",
+  Redshift: "analytics",
+  QuickSight: "analytics",
+  DataExchange: "analytics",
+  DataPipeline: "analytics",
+  Glue: "analytics",
+  LakeFormation: "analytics",
+  StepFunctions: "applicationintegration",
+  AppFlow: "applicationintegration",
+  EventBridge: "applicationintegration",
+  Events: "applicationintegration",
+  MQ: "applicationintegration",
+  SNS: "applicationintegration",
+  SQS: "applicationintegration",
+  AppSync: "applicationintegration",
+  ManagedBlockchain: "blockchain",
+  CloudWatch: "managementgovernance",
+  AutoScaling: "managementgovernance",
+  Chatbot: "managementgovernance",
+  CloudFormation: "managementgovernance",
+  CloudTrail: "managementgovernance",
+  ComputeOptimizer: "managementgovernance",
+  Config: "managementgovernance",
+  ControlTower: "managementgovernance",
+  ConsoleMobileApplication: "managementgovernance",
+  LicenseManager: "managementgovernance",
+  OpsWorks: "managementgovernance",
+  Organizations: "managementgovernance",
+  ServiceCatalog: "managementgovernance",
+  SystemsManager: "managementgovernance",
+  TrustedAdvisor: "managementgovernance",
+  EC2: "compute",
+  AutoScaling: "compute",
+  Lightsail: "compute",
+  Batch: "compute",
+  ElasticBeanstalk: "compute",
+  Lambda: "compute",
+  Outposts: "compute",
+  ServerlessApplicationRepository: "compute",
+  Wavelength: "compute",
+  ElasticContainerRegistry: "containers",
+  ECS: "containers",
+  EKS: "containers",
+  Fargate: "containers",
+  Aurora: "database",
+  DynamoDB: "database",
+  DocumentDB: "database",
+  ElastiCache: "database",
+  Keyspaces: "database",
+  Neptune: "database",
+  QuantumLedgerDatabase: "database",
+  RDS: "database",
+  RDSonVMware: "database",
+  Redshift: "database",
+  Timestream: "database",
+  DatabaseMigrationService: "database",
+  VPC: "networkingcontentdelivery",
+  APIGateway: "networkingcontentdelivery",
+  CloudFront: "networkingcontentdelivery",
+  Route53: "networkingcontentdelivery",
+  PrivateLink: "networkingcontentdelivery",
+  AppMesh: "networkingcontentdelivery",
+  CloudMap: "networkingcontentdelivery",
+  DirectConnect: "networkingcontentdelivery",
+  GlobalAccelerator: "networkingcontentdelivery",
+  TransitGateway: "networkingcontentdelivery",
+  ElasticLoadBalancing: "networkingcontentdelivery",
+  IAM: "securityidentitycomplicance",
+  Cognito: "securityidentitycomplicance",
+  Detective: "securityidentitycomplicance",
+  GuardDuty: "securityidentitycomplicance",
+  Inspector: "securityidentitycomplicance",
+  Macie: "securityidentitycomplicance",
+  Artifact: "securityidentitycomplicance",
+  CertificateManager: "securityidentitycomplicance",
+  CloudHSM: "securityidentitycomplicance",
+  DirectoryService: "securityidentitycomplicance",
+  FirewallManager: "securityidentitycomplicance",
+  KMS: "securityidentitycomplicance",
+  ResourceAccessManager: "securityidentitycomplicance",
+  SecretsManager: "securityidentitycomplicance",
+  SecurityHub: "securityidentitycomplicance",
+  Shield: "securityidentitycomplicance",
+  WAF: "securityidentitycomplicance",
+  S3: "storage",
+  EBS: "storage",
+  EFS: "storage",
+  Backup: "storage",
+  SnowFamily: "storage",
+  StorageGateway: "storage",
+};
+
+const serviceTranslation = {
+  iam: "identity_and_access_management",
+  kms: "key_management_service",
+  stepfunctions: "step_functions",
+  events: "eventbridge",
+  logs: "cloudwatch",
+};
+
+function getIcon(type) {
+  let icon = icons[type];
+  if (icon) {
+    icon.fillColor = colors[icon.serviceType].fillColor;
+    icon.gradientColor = colors[icon.serviceType].gradientColor;
+  } else {
+    const serviceName = type.split("::")[1];
+    const group = serviceTypeMap[serviceName];
+    const color = colors[group];
+    const translatedName = serviceTranslation[serviceName.toLowerCase()];
+    icon = {
+      icon: "mxgraph.aws4." + (translatedName || serviceName.toLowerCase()),
+      fillColor: color ? color.fillColor : "#aaaaaa",
+      gradientColor: color ? color.gradientColor : "#aaaaaa",
+    };
+  }
+  return `outlineConnect=0;fontColor=#B3B3B3;gradientColor=${icon.gradientColor};gradientDirection=north;fillColor=${icon.fillColor};strokeColor=#ffffff;dashed=0;verticalLabelPosition=bottom;verticalAlign=top;align=center;html=1;fontSize=12;fontStyle=0;aspect=fixed;shape=mxgraph.aws4.resourceIcon;resIcon=${icon.icon};`;
+}
+
+module.exports = {
+  getIcon,
+};

package/resources/JsonUtil.js

@@ -0,0 +1,186 @@
+const templateCache = require("../shared/templateCache");
+
+function createPseudoResources(template, current) {
+  current = current || template.Resources;
+  for (var k in current) {
+    if (current[k] && current[k]["Fn::Join"]) {
+      let joinList = current[k]["Fn::Join"][1];
+      if (!Array.isArray(joinList)) {
+        joinList = [joinList];
+      }
+      if (
+        joinList.filter(
+          (p) => typeof p === "object" && (!p.Ref || !p.Ref.startsWith("AWS::"))
+        )
+      ) {
+        return;
+      }
+      current[k] = (Array.isArray(joinList)
+        ? joinList
+            .map((p) => {
+              if (p[Object.keys(p)[0]] === "object") {
+                return "";
+              }
+              if (Array.isArray(p[Object.keys(p)[0]])) {
+                return "[]";
+              }
+              if (typeof p === "object" && p.Ref && p.Ref.startsWith("AWS::")) {
+                return null;
+              }
+              return typeof p === "object"
+                ? p[Object.keys(p)[0]].replace(/::/g, "-")
+                : p;
+            })
+            .filter((p) => p)
+        : [joinList]
+      ).join(current[k]["Fn::Join"][0]);
+    }
+    if (typeof current[k] === "object" && current[k] !== null) {
+      createPseudoResources(template, current[k]);
+    } else if (
+      typeof current[k] === "string" &&
+      current[k].startsWith("arn:")
+    ) {
+      current[k] = current[k].replace(/\$\{AWS\:\:(.+?)\}/g, "").toLowerCase();
+      if (!current[k]) {
+        return;
+      }
+      const split = current[k].split(":");
+      const service = split[2];
+      const resourceType = split[5]
+        ? split[5].split("/")[0].replace(/[\W_]+/g, "")
+        : "";
+      const name = `${split[2]} ${split[3]} ${split[4]}\n${split.slice(-1)[0]}`;
+      template.Resources[name] = {
+        Type: `External resource (aws::${service}::${resourceType})`,
+      };
+      current[k] = {
+        Ref: name,
+      };
+    }
+  }
+}
+
+function findAllValues(obj, keyArray, keyName, path) {
+  path = path || "$";
+  for (const prop of Object.keys(obj)) {
+    if (prop === keyName) {
+      let values = obj[prop];
+      if (Array.isArray(values)) {
+        values = obj[prop][instrisicFunctionIndex(prop)];
+      }
+
+      if (!Array.isArray(values)) {
+        values = [values];
+      }
+
+      if (prop === "Fn::Sub") {
+        const pattern = /\$\{(.+?)\}/g;
+        let match;
+        const multiValue = [];
+        while ((match = pattern.exec(values[0])) != null) {
+          multiValue.push([match[1].split(".")[0]]);
+        }
+        values = multiValue.map((p) => p[0]);
+      }
+      if (prop === "Fn::ImportValue") {
+        const split = typeof values[0] ==="string" && values[0].split(":");
+        if (split.length == 2) {
+          const stackName = split[0];
+          const exportName = split[1];
+          const value = templateCache.templates[stackName] ? templateCache.templates[stackName].Outputs[exportName].Value : {"Fn::ImportValue": "Unknown"};
+          const intrinsicFunction = Object.keys(value)[0];
+          const prefix = stackName === templateCache.rootTemplate ? "root" : stackName;
+          values[0] = `${prefix}.${value[intrinsicFunction]}`;
+        }
+      }
+
+      values = [values];
+
+      for (const v of values) {
+        const item = {
+          key: prop,
+          value: v.filter((p) => typeof p === "string" && !p.startsWith("AWS::")),
+          path: path.split(".Fn::")[0],
+        };
+        if (item.value.length) {
+          keyArray.push(item);
+        }
+      }
+    }
+    if (
+      !obj[prop] ||
+      typeof obj[prop] !== "object" ||
+      typeof obj[prop] === "string" ||
+      obj[prop] instanceof String
+    ) {
+      continue;
+    }
+
+    if (Array.isArray(obj[prop])) {
+      obj[prop].forEach((child, i) =>
+        findAllValues(child, keyArray, keyName, `${path}.${prop}`)
+      );
+    } else {
+      findAllValues(obj[prop], keyArray, keyName, `${path}.${prop}`);
+    }
+  }
+}
+
+function instrisicFunctionIndex(prop) {
+  switch (prop) {
+    case "Fn::GetAtt":
+      return 0;
+    case "Fn::Join":
+      return 1;
+  }
+  return 0;
+}
+
+function isJson(str) {
+  try {
+    JSON.parse(str);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+function pathToDescriptor(path, filterConfig) {
+  if (filterConfig.edgeMode === "Off") {
+    return "";
+  }
+  if (path.startsWith("$.Properties.Environment")) {
+    return "Variable";
+  }
+
+  if (path.startsWith("$.Properties.Policies")) {
+    const split = path.split(".");
+    return split[3];
+  }
+
+  if (
+    path.startsWith(
+      "$.Properties.EventInvokeConfig.DestinationConfig.OnFailure"
+    )
+  ) {
+    return "OnFailure";
+  }
+
+  if (
+    path.startsWith(
+      "$.Properties.EventInvokeConfig.DestinationConfig.OnSuccess"
+    )
+  ) {
+    return "OnSuccess";
+  }
+
+  return path.split(".").slice(-1)[0];
+}
+
+module.exports = {
+  createPseudoResources,
+  findAllValues,
+  isJson,
+  pathToDescriptor,
+};

package/shared/templateCache.js

@@ -0,0 +1,6 @@
+const templates = {};
+let rootTemplate
+module.exports = {
+    templates,
+    rootTemplate
+}

package/shared/templateParser.js

@@ -0,0 +1,128 @@
+const fs = require("fs");
+const path = require("path");
+const YAML = require("yaml-cfn");
+const jsonUtil = require("../resources/JsonUtil");
+const cp = require("child_process");
+const templateCache = require("./templateCache");
+
+function get(cmd) {
+  let templateString = "";
+  try {
+    if (cmd.templateFile === "template.yaml or cdk.json") {
+      cmd.templateFile = "template.yaml";
+    }
+    templateString = fs.readFileSync(cmd.templateFile);
+  } catch {
+    try {
+      templateString = fs.readFileSync("cdk.json").toString();
+    } catch {
+      console.log(
+        `Can't find ${cmd.templateFile} or cdk.json. Specify location with -t flag, for example 'cfn-dia html -t mytemplate.yaml'`
+      );
+      process.exit(1);
+    }
+  }
+
+  const isJson = jsonUtil.isJson(templateString);
+  const parser = isJson ? JSON.parse : YAML.yamlParse;
+
+  let template = parser(templateString);
+  if (template.app) {
+    template = fromCDK(cmd);
+  }
+  templateCache.templates["root"] = template;
+  if (!template.Resources) return { isJson, template };
+  Object.keys(template.Resources)
+    .filter((p) => template.Resources[p].Type === "AWS::CloudFormation::Stack")
+    .map((p) => {
+      const res = template.Resources[p];
+      if (
+        !res.StackImport &&
+        typeof res.Properties.TemplateURL === "string" &&
+        !res.Properties.TemplateURL.startsWith("s3://")
+      ) {
+        templateString = fs.readFileSync(res.Properties.TemplateURL);
+        const isJson = jsonUtil.isJson(templateString);
+        const parser = isJson ? JSON.parse : YAML.yamlParse;
+        const parsedTemplate = parser(templateString);
+        template.Resources[p].Template = parsedTemplate;
+        templateCache.templates[p] = parsedTemplate;
+      }
+    });
+  Object.keys(template.Resources)
+    .filter((p) => template.Resources[p].Type === "AWS::Serverless::Function")
+    .map((functionName) => {
+      const res = template.Resources[functionName];
+      const events = res.Properties.Events;
+      if (events) {
+        for (const eventName of Object.keys(events)) {
+          const event = events[eventName];
+          if (["EventBridgeRule", "CloudWatchEvent"].includes(event.Type)) {
+            template.Resources[functionName + eventName] = {
+              Type: "AWS::Events::Rule",
+              Properties: {
+                EventBusName: event.Properties.EventBusName || "default",
+                EventPattern: event.Properties.Pattern,
+                State: "ENABLED",
+                Targets: [{ Arn: { "Fn::GetAtt": [functionName, "Arn"] },  Id: "EventId"}],
+              },
+            };
+          }
+          if (["Api"].includes(event.Type)) {
+            template.Resources[functionName + eventName] = {
+              Type: "AWS::ApiGateway::RestApi",
+              Properties: {
+                Integration: [{ Arn: { "Fn::GetAtt": [functionName, "Arn"] },  Id: "EventId"}],
+              },
+            };
+          }
+          if (["HttpApi"].includes(event.Type)) {
+            template.Resources[functionName + eventName] = {
+              Type: "AWS::ApiGatewayV2::Api",
+              Properties: {
+                Integration: [{ Arn: { "Fn::GetAtt": [functionName, "Arn"] },  Id: "EventId"}],
+              },
+            };
+          }
+        }
+      }
+    });
+  return { isJson, template };
+}
+
+function fromCDK(cmd) {
+  if (!cmd.skipSynth) {
+    cp.execSync("cdk synth -o " + cmd.cdkOutput);
+  }
+  const manifestFile = fs.readFileSync(path.join(cmd.cdkOutput, "manifest.json"));
+  const treeFile = fs.readFileSync(path.join(cmd.cdkOutput, "tree.json"));
+  const manifest = JSON.parse(manifestFile);
+  const tree = JSON.parse(treeFile);
+  const includeStacks = cmd.stacks && (typeof cmd.stacks !== 'boolean') ? cmd.stacks.split(",").map(p=>p.trim()) : null;
+  let stacks = Object.keys(manifest.artifacts).filter((p) => p !== "Tree" && (!includeStacks || includeStacks.includes(p)));
+  const parentStack = Object.keys(tree.tree.children).filter((p) => p !== "Tree" && !p.includes(".assets") && (!includeStacks || includeStacks.includes(p)))[0];
+  const template = fs.readFileSync(
+    path.join(cmd.cdkOutput, `${parentStack}.template.json`)
+  );
+  const parsedTemplate = JSON.parse(template);
+  templateCache.templates[parentStack] = parsedTemplate;
+  templateCache.rootTemplate = parentStack;
+  stacks = stacks.filter(p => p != parentStack);
+  for (const stack of stacks.filter(p => !p.endsWith(".assets"))) {
+    const childTemplate = fs.readFileSync(
+      path.join(cmd.cdkOutput, `${stack}.template.json`)
+    );
+    const parsedChildTemplate = JSON.parse(childTemplate);
+    parsedTemplate.Resources[stack] = {
+      Type: "AWS::CloudFormation::Stack",
+      Template: parsedChildTemplate,
+      StackImport: true,
+    };
+    templateCache.templates[stack] = parsedChildTemplate;
+  }
+  return parsedTemplate;
+}
+
+module.exports = {
+  get,
+};

package/tests/resources/JsonUtil.spec.js

@@ -0,0 +1,32 @@
+const path = require("path");
+const fs = require("fs");
+
+const templateStr = fs.readFileSync(path.join(__dirname, "..", "template.json"));
+const template = JSON.parse(templateStr.toString());
+
+const jsonUtil = require("../../resources/JsonUtil");
+
+test("Find Ref", async () => {
+  const values = [];
+  jsonUtil.findAllValues(template.Resources.Function2.Properties, values, "Ref");
+  expect(values.length).toBe(2);
+});
+
+test("Find Fn::GetAtt", async () => {
+  const values = [];
+  jsonUtil.findAllValues(template.Resources.Function2.Properties, values, "Fn::GetAtt");
+  console.log(values);
+  expect(values.length).toBe(2);
+});
+
+test("Find Fn::Sub", async () => {
+  const values = [];
+  jsonUtil.findAllValues(template.Resources.Function2.Properties, values, "Fn::Sub");
+  expect(values.length).toBe(1);
+});
+
+// test("Find Ref in nested Join", async () => {
+//   const values = [];
+//   jsonUtil.findAllValues(template.Resources.Function2.Properties, values, "Fn::Sub");
+//   expect(values.length).toBe(1);
+// });