Merge pull request #257 from Dan-Nolan/task/ci_testing

Adds a CI Script for testing all content

Author: Dan-Nolan

ci/.gitignore

@@ -0,0 +1,2 @@
+.env
+!.gitignore

ci/config.js

@@ -0,0 +1,23 @@
+require("dotenv").config();
+
+const EXECUTION_RESULTS = {
+  NONE: 0,
+  SUCCESS: 1,
+  FAILED: 2
+}
+
+const LANGUAGE_VERSIONS = {
+  solidity: ['0.6.12', '0.7.5', '0.8.4'],
+  javascript: ['10.x', '10.x/babel']
+}
+
+const GRAPH_API = process.env.GRAPH_API || "http://localhost:3040/graphql";
+
+const RUN_URL = process.env.RUN_URL || "https://relayer-staging.chainshot.com/run/";
+
+module.exports = {
+  LANGUAGE_VERSIONS,
+  EXECUTION_RESULTS,
+  GRAPH_API,
+  RUN_URL,
+}

ci/execute/executeGroups.js

@@ -0,0 +1,56 @@
+const executeStages = require("./executeStages");
+const { EXECUTION_RESULTS } = require('../config');
+
+function sendProcessMessage(msg) {
+  // process.send not defined outside of child processes
+  // this is used for the Builder CLI
+  if(process.send) {
+    process.send(msg);
+  }
+}
+
+function executeGroups(groups) {
+  const stageContainers = groups.reduce((arr, group) => {
+    const containers = group.stageContainers.map((x) => ({ ...x, stageContainerGroup: group }))
+    return arr.concat(containers);
+  }, []);
+
+  const promises = new Array(stageContainers.length).fill(0).map(async (_, j) => {
+    const stageContainer = stageContainers[j];
+
+    const { version, stages, stageContainerGroup } = stageContainer;
+    const { title } = stageContainerGroup;
+
+    console.log(`Running ${title} ${version}...`);
+    const results = await executeStages(stages);
+    const executedResults = results.filter(x => x !== EXECUTION_RESULTS.NONE);
+    if(executedResults.length === 0) {
+      return;
+    }
+
+    console.log(`${title} ${version} results:`);
+    executedResults.forEach((result, i) => {
+      const stage = stageContainer.stages[i];
+      if(result === EXECUTION_RESULTS.SUCCESS) {
+        console.log(`✔️ ${stage.title} passed!`);
+        sendProcessMessage({ type: "RESULT", data: {
+          success: true,
+          version: `${title} ${version}`,
+          stage: stage.title
+        }});
+      }
+      else {
+        console.log(`✘ ${stage.title} failed!`);
+        sendProcessMessage({ type: "RESULT", data: {
+          success: false,
+          version: `${title} ${version}`,
+          stage: stage.title
+        }});
+      }
+    });
+  });
+
+  return Promise.all(promises);
+}
+
+module.exports = executeGroups;

ci/execute/executeStage.js

@@ -0,0 +1,28 @@
+const axios = require('axios');
+const { RUN_URL } = require('../config');
+
+async function executeStage(stage) {
+  const files = stage.codeFiles
+    .filter(x => x.executable)
+    .map(({ id, initialCode, executablePath, hasProgress }) => {
+      if(hasProgress) {
+        const solution = stage.solutions.find(x => x.codeFileId === id);
+        return { contents: solution.code, path: executablePath }
+      }
+      return { contents: initialCode, path: executablePath }
+    });
+
+  const { id, languageVersion, language, testFramework, forkBlockNumber } = stage;
+
+  return axios.post(RUN_URL, {
+    stageId: stage.id,
+    files,
+    languageVersion,
+    language,
+    testFramework,
+    forkBlockNumber,
+    noCache: true
+  });
+}
+
+module.exports = executeStage;

ci/execute/executeStages.js

@@ -0,0 +1,30 @@
+const { LANGUAGE_VERSIONS, EXECUTION_RESULTS } = require('../config');
+const executeStage = require("./executeStage");
+
+async function timeout(seconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, seconds);
+  });
+}
+
+async function executeStages(stages) {
+  return Promise.all(stages.map(async (stage, i) => {
+    const { language, languageVersion } = stage;
+
+    await timeout(i * 500);
+
+    if((LANGUAGE_VERSIONS[language] || []).indexOf(languageVersion) < 0) {
+      return EXECUTION_RESULTS.NONE;
+    }
+    try {
+      const { data: { result: { completed }} } = await executeStage(stage);
+      return completed ? EXECUTION_RESULTS.SUCCESS : EXECUTION_RESULTS.FAILED;
+    }
+    catch(ex) {
+      console.log(ex.message);
+      return EXECUTION_RESULTS.FAILED;
+    }
+  }));
+}
+
+module.exports = executeStages;

ci/package-lock.json

@@ -0,0 +1,16 @@
+{
+  "name": "ci",
+  "version": "1.0.0",
+  "main": "executeStage.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^0.21.1"
+  },
+  "devDependencies": {},
+  "description": ""
+}

ci/package.json

@@ -0,0 +1,15 @@
+const axios = require('axios');
+const { GRAPH_API } = require('../config');
+const { stageContainerGroupIds } = require("./queries");
+
+async function getStageContainerGroupIds() {
+  const r1 = await axios.post(GRAPH_API, {
+    query: stageContainerGroupIds,
+    variables: { filter: '{ "productionReady": true }' }
+  });
+  const { data: { data: { stageContainerGroups: idObjects }}} = r1;
+
+  return idObjects.map(x => x.id);
+}
+
+module.exports = getStageContainerGroupIds;

ci/query/getStageContainerGroupIds.js

@@ -0,0 +1,12 @@
+const axios = require('axios');
+const { GRAPH_API } = require('../config');
+const { stageContainerGroupsByIds } = require("./queries");
+
+async function getStageContainerGroups(ids) {
+  const variables = { containsId: ids };
+  const r2 = await axios.post(GRAPH_API, { query: stageContainerGroupsByIds, variables });
+  const { data: { data: { stageContainerGroups }}} = r2;
+  return stageContainerGroups;
+}
+
+module.exports = getStageContainerGroups;

ci/query/getStageContainerGroups.js

@@ -0,0 +1,41 @@
+const stageContainerGroupIds = `
+query filterStageContainerGroups($filter: String) {
+  stageContainerGroups(filter: $filter) {
+    id
+	}
+}`;
+
+const stageContainerGroupsByIds = `
+query stageContainerGroupsByIds($containsId: [String]) {
+  stageContainerGroups(containsId: $containsId) {
+    id
+    title
+    stageContainers {
+      version
+      stages {
+        id
+        title
+        languageVersion
+        language
+        testFramework
+        forkBlockNumber
+        solutions {
+          codeFileId
+          code
+        }
+        codeFiles {
+          id
+          name
+          hasProgress
+          executable
+          executablePath
+          readOnly
+          testFixture
+          initialCode
+        }
+      }
+    }
+	}
+}`;
+
+module.exports = { stageContainerGroupIds, stageContainerGroupsByIds }