.gitlab-ci.yml

-image: node:6
+image: node:8
 
 # Set up MySQL test-database
 services:
-  - mysql:latest
+  - mysql:5.5
 
 # Configure test-database
 variables:
-  MYSQL_DATABASE: db
+  MYSQL_DATABASE: supertestdb
   MYSQL_ROOT_PASSWORD: secret
-  
+
 # Install node libraries
 before_script:
   - npm install
-  
+
 # Run JEST tests
 run_tests:
   stage: test
   script:
     - npm test
-    
+  artifacts:
+    paths:
+      - coverage/
+
 # Publish coverage report on gitlab-pages
 pages:
   stage: deploy
+  dependencies:
+    - run_tests
   script:
-  - mkdir .public
-  - cp -r coverage/* .public
-  - mv .public public
+    - mkdir .public
+    - cp -r coverage/* .public
+    - mv .public public
   artifacts:
     paths:
-    - public
+      - public
   only:
-  - master
-
+    - master

README.md

+# Eksempel med Node/Jest/MySQL og GitLabCI
+
+Dette er et prosjekt som implementerer en REST-service med et DAO-objekt og tester dette med Node/JEST.
+
+Prosjektet bruker GitLab CI med et Docker-image for Node og en service for MySQL. 
+
+Testen bruker MySQL-servicen slik at testen har en annen database enn REST-tjenesten.
\ No newline at end of file

create_tables.sql

-CREATE TABLE`person` (
-  `id` int(11) NOT NULL,
-  `navn` varchar(256) NOT NULL,
-  `alder` int(3) DEFAULT NULL,
-  `adresse` varchar(256) NOT NULL,
-  `bilde_base64` longtext
-) ENGINE=InnoDB DEFAULT CHARSET=latin1;
\ No newline at end of file

dao/calculator.js

+module.exports = class Calculator {
+  constructor() {}
+
+  calculate(expression) {
+    let pos = expression.indexOf("+");
+    if (pos >= 0) {
+      return (
+        this.calculate(expression.substr(0, pos)) +
+        this.calculate(expression.substr(pos + 1))
+      );
+    } else {
+      pos = expression.indexOf("-");
+      if (pos >= 0) {
+        return (
+          this.calculate(expression.substr(0, pos)) -
+          this.calculate(expression.substr(pos + 1))
+        );
+      } else {
+        // Remove ALL whitespaces
+        expression = expression.replace(/\s+/g, "");
+        if (expression === "") {
+          return 0;
+        }
+
+        let num = Number(expression);
+        if (!Number.isInteger(num)) {
+          console.log("'" + expression + "' is not an integer");
+          throw new Error("'" + expression + "' is not an integer");
+        } else {
+          return num;
+        }
+      }
+    }
+    return 0;
+  }
+};

dao/calculator.test.js

+const Calculator = require("./calculator");
+let calc = new Calculator();
+
+beforeEach(() => {
+  console.log("calculator.test: beforeEach");
+});
+
+afterEach(() => {
+  console.log("calculator.test: afterEach");
+});
+
+beforeAll(() => {
+  console.log("calculator.test: beforeAll");
+});
+
+afterAll(() => {
+  console.log("calculator.test: afterAll");
+});
+
+test("test plus and minus with any number of arguments", () => {
+  expect(calc.calculate("")).toBe(0);
+  expect(calc.calculate("2")).toBe(2);
+  expect(calc.calculate("2+2")).toBe(4);
+  expect(calc.calculate("2+4+3-3+5")).toBe(11);
+});
+
+test("test that whitespace is allowed", () => {
+  expect(calc.calculate(" \t\n\r2 +\n3")).toBe(5);
+});
+
+test("test that only digits and plus and minus and whitespace is allowed", () => {
+  let illegal = ["1.2", "1,2", "1/2", "1*2", "1 plus 2"];
+  for (i in illegal) {
+    expect(() => calc.calculate(illegal[i])).toThrow();
+  }
+});

dao/create_tables.sql

+DROP TABLE IF EXISTS person;
+
+CREATE TABLE person  (
+  id int(11) NOT NULL AUTO_INCREMENT,
+  navn varchar(256) NOT NULL,
+  alder int(3) DEFAULT NULL,
+  adresse varchar(256) NOT NULL,
+  bilde_base64 longtext,
+  PRIMARY KEY (id)
+) ENGINE=InnoDB DEFAULT CHARSET=latin1;

dao/create_testdata.sql

+INSERT INTO person (id, navn, alder, adresse) VALUES
+    (1, 'Hei Sveisen', 21, 'Gata 1'),
+    (2, 'Hei Heisen', 22, 'Gata 2');

dao/dao.js

+module.exports = class Dao {
+  constructor(pool) {
+    // Dependency Injection
+    this.pool = pool;
+  }
+
+  query(sql, params, callback) {
+    this.pool.getConnection((err, connection) => {
+      console.log("dao: connected to database");
+      if (err) {
+        console.log("dao: error connecting");
+        callback(500, { error: "feil ved ved oppkobling" });
+      } else {
+        console.log("dao: running sql: " + sql);
+        connection.query(sql, params, (err, rows) => {
+          connection.release();
+          if (err) {
+            console.log(err);
+            callback(500, { error: "error querying" });
+          } else {
+            console.log("dao: returning rows");
+            callback(200, rows);
+          }
+        });
+      }
+    });
+  }
+};

dao/dum.test.js

+beforeEach(() => {
+  console.log("dum.test: beforeEach");
+});
+
+afterEach(() => {
+  console.log("dum.test: afterEach");
+});
+
+beforeAll(() => {
+  console.log("dum.test: beforeAll");
+});
+
+afterAll(() => {
+  console.log("dum.test: afterAll");
+});
+
+test("test at 1 er 1", () => {
+  console.log("dum.test: test 1");
+  expect(1).toBe(1);
+});
+
+test("test at 2 er 2", () => {
+  console.log("dum.test: test 2");
+  expect(2).toBe(2);
+});
+
+test("test alle expects", () => {
+  // Kjør kode
+  // før vi verifiserer resultatet
+
+  expect(2 + 2).toBe(4);
+  expect(2 + 2).toEqual(4);
+  expect(1 + 1).not.toBe(0);
+  expect("data").toEqual("data");
+  expect(true).toBeTruthy();
+  expect(false).not.toBeTruthy();
+  expect("1").toBeDefined();
+  expect("1").not.toBeUndefined();
+  expect(2).toBeLessThan(5);
+  expect("Christoph").toMatch(/stop/); // Regular expression
+});
+
+someCode = () => {
+  throw Error("Feil");
+};
+
+test("test exception", () => {
+  expect(someCode).toThrow();
+});

dao/persondao.js

+const Dao = require("./dao.js");
+
+module.exports = class PersonDao extends Dao {
+  getAll(callback) {
+    super.query("select navn, alder, adresse from person", [], callback);
+  }
+
+  getOne(id, callback) {
+    super.query(
+      "select navn, alder, adresse from person where id=?",
+      [id],
+      callback
+    );
+  }
+
+  createOne(json, callback) {
+    var val = [json.navn, json.adresse, json.alder];
+    super.query(
+      "insert into person (navn,adresse,alder) values (?,?,?)",
+      val,
+      callback
+    );
+  }
+};

dao/persondao.test.js

 var mysql = require("mysql");
 
+const PersonDao = require("./persondao.js");
+const runsqlfile = require("./runsqlfile.js");
+
+// GitLab CI Pool
 var pool = mysql.createPool({
   connectionLimit: 1,
   host: "mysql",
   user: "root",
   password: "secret",
-  database: "db",
-  debug: false
+  database: "supertestdb",
+  debug: false,
+  multipleStatements: true
+});
+
+let personDao = new PersonDao(pool);
+
+beforeAll(done => {
+  runsqlfile("dao/create_tables.sql", pool, () => {
+    runsqlfile("dao/create_testdata.sql", pool, done);
+  });
+});
+
+afterAll(() => {
+  pool.end();
+});
+
+test("get one person from db", done => {
+  function callback(status, data) {
+    console.log(
+      "Test callback: status=" + status + ", data=" + JSON.stringify(data)
+    );
+    expect(data.length).toBe(1);
+    expect(data[0].navn).toBe("Hei Sveisen");
+    done();
+  }
+
+  personDao.getOne(1, callback);
 });
 
-test("query db", () => {
-  console.log("Connecting to database");
-/*  pool.getConnection((err, connection) => {
-    console.log("Connected to database");
-    if (err) {
-      console.log("Feil ved kobling til databasen");
-      res.json({ error: "feil ved ved oppkobling" });
-    } else {
-      connection.query(
-        "select navn, alder, adresse from person",
-        (err, rows) => {
-          connection.release();
-          if (err) {
-            console.log(err);
-            res.json({ error: "error querying" });
-          } else {
-            console.log("returning rows");
-            res.json(rows);
-          }
-        }
-      );
-    }
-  }); */
-
-  expect(3).toBe(3);
-});
\ No newline at end of file
+test("get unknown person from db", done => {
+  function callback(status, data) {
+    console.log(
+      "Test callback: status=" + status + ", data=" + JSON.stringify(data)
+    );
+    expect(data.length).toBe(0);
+    done();
+  }
+
+  personDao.getOne(0, callback);
+});
+
+test("add person to db", done => {
+  function callback(status, data) {
+    console.log(
+      "Test callback: status=" + status + ", data=" + JSON.stringify(data)
+    );
+    expect(data.affectedRows).toBeGreaterThanOrEqual(1);
+    done();
+  }
+
+  personDao.createOne(
+    { navn: "Nils Nilsen", alder: 34, adresse: "Gata 3" },
+    callback
+  );
+});
+
+test("get all persons from db", done => {
+  function callback(status, data) {
+    console.log(
+      "Test callback: status=" + status + ", data.length=" + data.length
+    );
+    expect(data.length).toBeGreaterThanOrEqual(2);
+    done();
+  }
+
+  personDao.getAll(callback);
+});

dao/runsqlfile.js

+var mysql = require("mysql");
+var fs = require("fs");
+
+module.exports = function run(filename, pool, done) {
+  console.log("runsqlfile: reading file " + filename);
+  let sql = fs.readFileSync(filename, "utf8");
+  pool.getConnection((err, connection) => {
+    if (err) {
+      console.log("runsqlfile: error connecting");
+      done();
+    } else {
+      console.log("runsqlfile: connected");
+      connection.query(sql, (err, rows) => {
+        connection.release();
+        if (err) {
+          console.log(err);
+          done();
+        } else {
+          console.log("runsqlfile: run ok");
+          done();
+        }
+      });
+    }
+  });
+};

dao/sum.test.js

-const sum = require('./sum');
+const sum = require("./sum");
 
-
-/*
 beforeEach(() => {
-  initializeCityDatabase();
+  console.log("sum.test: beforeEach");
 });
 
 afterEach(() => {
-  clearCityDatabase();
+  console.log("sum.test: afterEach");
 });
 
-test('city database has Vienna', () => {
-  expect(isCity('Vienna')).toBeTruthy();
+beforeAll(() => {
+  console.log("sum.test: beforeAll");
 });
 
-test('city database has San Juan', () => {
-  expect(isCity('San Juan')).toBeTruthy();
-}); */
+afterAll(() => {
+  console.log("sum.test: afterAll");
+});
 
 test("adds 1 + 2 to equal 3", () => {
   console.log("Running simple test");
   expect(sum(1, 2)).toBe(3);
-});
\ No newline at end of file
+});

package.json

 {
-	"name": "myPackage",
-	"jest": {
-        "verbose": true,
-		"collectCoverage": true,
-        "coverageReporters": ["json", "html"]
-    },
-	"version": "0.0.1",
-	"dependencies": {
-		"body-parser": "^1.18.3",
-		"express": "^4.16.3",
-		"jest": "^23.6.0",
-		"mysql": "^2.16.0"
-	},
-	"scripts": {
-		"test": "jest"
-	}
+  "name": "myPackage",
+  "jest": {
+    "verbose": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "html"
+    ]
+  },
+  "version": "0.0.1",
+  "dependencies": {
+    "body-parser": "^1.18.3",
+    "express": "^4.16.3",
+    "fs": "0.0.1-security",
+    "jest": "^23.6.0",
+    "mysql": "^2.16.0"
+  },
+  "scripts": {
+    "test": "jest"
+  }
 }

server.js

+var express = require("express");
+var mysql = require("mysql");
+var bodyParser = require("body-parser");
+var app = express();
+var apiRoutes = express.Router();
+app.use(bodyParser.json()); // for å tolke JSON
+const PersonDao = require("./dao/persondao.js");
+
+var pool = mysql.createPool({
+  connectionLimit: 2,
+  host: "mysql.stud.iie.ntnu.no",
+  user: "nilstesd",
+  password: "lqqWcMzq",
+  database: "nilstesd",
+  debug: false
+});
+
+let personDao = new PersonDao(pool);
+
+app.get("/person", (req, res) => {
+  console.log("/person: fikk request fra klient");
+  personDao.getAll((status, data) => {
+    res.status(status);
+    res.json(data);
+  });
+});
+
+app.get("/person/:personId", (req, res) => {
+  console.log("/person/:personId: fikk request fra klient");
+  personDao.getOne(req.params.personId, (status, data) => {
+    res.status(status);
+    res.json(data);
+  });
+});
+
+app.post("/person", (req, res) => {
+  console.log("Fikk POST-request fra klienten");
+  personDao.createOne(req.body, (status, data) => {
+    res.status(status);
+    res.json(data);
+  });
+});
+
+var server = app.listen(8080);