update tests and improve types

Author: lastlink

src/mermaid/src/diagrams/er/erDb.ts

@@ -4,6 +4,7 @@ import {
   DbEntityAttributesDefinition,
   DbEntityDefinition,
   DbRelationshipDefinition,
+  DbRelSpec,
 } from "../../../../types";
 // import mermaidAPI from '../../mermaidAPI';
 // import * as configApi from '../../../../../deps/mermaid/src/config'
@@ -69,7 +70,7 @@ const addRelationship = function (
   entA: string,
   rolA: string,
   entB: string,
-  rSpec: string
+  rSpec: DbRelSpec
 ) {
   const rel: DbRelationshipDefinition = {
     entityA: entA,

src/types/index.ts

@@ -24,32 +24,38 @@ export interface DiagramDefinition {
 export interface DbEntityAttributesDefinition {
   attributeType?: string;
   attributeName?: string;
-  attributeKeyType?: string;
+  attributeKeyType?: "PK" | "FK";
   attributeComment?: string;
 }
 
 export interface DbEntityDefinition {
   attributes: DbEntityAttributesDefinition[];
 }
 
+export interface DbRelSpec {
+  cardA: string;
+  cardB: string;
+  relType: string;
+}
+
 export interface DbRelationshipDefinition {
   entityA: string;
   roleA: string;
   entityB: string;
-  relSpec: string;
+  relSpec: DbRelSpec;
 }
 
 export interface DbDefinition {
   Cardinality: Record<string, string>;
   Identification: Record<string, string>;
   addEntity: (name: string) => void;
-  addAttributes: (entityName: string, attribs: any[]) => void;
+  addAttributes: (entityName: string, attribs: DbEntityAttributesDefinition[]) => void;
   getEntities: () => Record<string, DbEntityDefinition>;
   addRelationship: (
     entA: string,
     rolA: string,
     entB: string,
-    rSpec: string
+    rSpec: DbRelSpec
   ) => void;
   getRelationships: () => DbRelationshipDefinition[];
   clear: () => void;

tests/data/results/getSQLDataDefinition.json

@@ -0,0 +1,3 @@
+{
+    "Generate DDL examples Should generate create table SQL syntax": "CREATE TABLE \"Persons\" (\n\t\"City\" varchar(255),\n\t\"Address\" varchar(255),\n\t\"FirstName\" varchar(255),\n\t\"LastName\" varchar(255),\n\t\"PersonID\" int NOT NULL,\n\tPRIMARY KEY(\"PersonID\")\n);\n\nCREATE TABLE \"Orders\" (\n\t\"PersonID\" int NOT NULL,\n\t\"OrderID\" int NOT NULL,\n\tPRIMARY KEY(\"OrderID\")\n);\n\n"
+}

tests/generate-sql-ddl.spec.ts

@@ -0,0 +1,78 @@
+import { DbParser } from "../../src/generate-sql-ddl";
+import erDb from "../../src/mermaid/src/diagrams/er/erDb";
+import { DbEntityAttributesDefinition, DbRelSpec } from "../../src/types";
+import { getExpected, updateExpected } from "../utils/helper";
+
+const dataSource = "getSQLDataDefinition";
+describe("Generate DDL examples", () => {
+  it("Should generate create table SQL syntax", async () => {
+    const db = erDb;
+    let entityName = "Persons";
+    db.addEntity(entityName);
+    let attributes:DbEntityAttributesDefinition[] = [
+      {
+        attributeName: "PersonID",
+        attributeKeyType: "PK",
+        attributeType: "int",
+        attributeComment: "NOT NULL"
+      },
+      {
+        attributeName: "LastName",
+        attributeType: "varchar255"
+      },
+      {
+        attributeName: "FirstName",
+        attributeType: "varchar255"
+      },
+      {
+        attributeName: "Address",
+        attributeType: "varchar255"
+      },
+      {
+        attributeName: "City",
+        attributeType: "varchar255"
+      }
+    ];
+    db.addAttributes(entityName,attributes);
+
+    entityName = "Orders";
+    db.addEntity(entityName);
+    attributes = [
+      {
+        attributeName: "OrderID",
+        attributeKeyType: "PK",
+        attributeType: "int",
+        attributeComment: "NOT NULL"
+      },
+      {
+        attributeName: "PersonID",
+        attributeKeyType: "FK",
+        attributeType: "int",
+        attributeComment: "NOT NULL"
+      }
+    ];
+    db.addAttributes(entityName,attributes);
+
+    const relSpec:DbRelSpec= {
+      cardA: "ZERO_OR_MORE",
+      cardB: "ONLY_ONE",
+      relType: "IDENTIFYING"
+    };
+
+    db.addRelationship("Persons", entityName,`[Persons.PersonId] to [${entityName}.PersonId]`, relSpec);
+    // `erDiagram artists { }`;
+    const ddlSyntax = new DbParser("sqlite", db).getSQLDataDefinition();
+
+    const dataKey = expect.getState().currentTestName || "unknown";
+
+    const expectedResult = await getExpected(dataSource, dataKey);
+
+    if (ddlSyntax != expectedResult) {
+      await updateExpected(dataSource, dataKey, ddlSyntax);
+    }
+
+    // console.log(result);
+    expect(ddlSyntax).toStrictEqual(expectedResult);
+    // expect(ddlSyntax).toBe('CREATE TABLE artists');
+  });
+});

tests/src/generate-sql-ddl.spec.ts

@@ -0,0 +1,35 @@
+/* eslint-disable @typescript-eslint/no-var-requires */
+// import {fs} from "fs";
+import * as fs from "fs";
+// const fs = require("fs");
+const path = require("path");
+const base_DIR = path.join(__dirname, "../data/results");
+
+export async function getExpectedDict<T>(testData: string): Promise<Record<string, T | null>> {
+    const filePath = path.join(base_DIR, testData + ".json");
+    console.log(filePath);
+    if (await fs.existsSync(filePath)) {
+        const expectedResults: Record<string, T> = await JSON.parse(fs.readFileSync(filePath, "utf8"));
+        return expectedResults;
+    } else
+        return {};
+}
+
+export async function getExpected<T>(testData: string, key: string): Promise<T | null> {
+    const expectedResults = await getExpectedDict<T>(testData);
+    if (expectedResults[key]) {
+        return expectedResults[key];
+    } else {
+        return null;
+    }
+}
+
+export async function updateExpected<T>(testData: string, key: string, result: T | null) {
+    const expectedResults = await getExpectedDict<T>(testData);
+
+    expectedResults[key] = result;
+
+    const filePath = path.join(base_DIR, testData + ".json");
+    const stringResults = JSON.stringify(expectedResults, null, 4);
+    await fs.writeFileSync(filePath, stringResults);
+}