auto-tdd 0.1.3

package/README.md

@@ -0,0 +1,24 @@
+[![Build Status](https://travis-ci.org/unsegnor/new-app.svg?branch=master)](https://travis-ci.org/unsegnor/new-app)
+
+# new-app
+New application schema with:
+- Cucumber tests
+- Integration tests
+- Unit tests
+- Mutation testing
+- Ports and adapters templates
+- Github actions for CI
+- Component tests using docker containers
+
+## Getting started
+1. Rename the product name on package.json
+2. Set the repository, bugs and homepage urls
+3. Set the keywords, description and author
+4. Set the dockerHubUsername property if you want to automatically publish your docker images
+4. Set repository secrets in GitHub:
+    4.1 One named NPM_TOKEN with an automation token to publish the package to NPM
+    4.2 One named DOCKERHUB_TOKEN with a token from DockerHub to publish the images
+
+## Run all tests
+
+    npm test

package/TODO

@@ -0,0 +1,17 @@
+Add property based testing
+Make a UI to create tests (read and write on a local file)
+Deploy docker container as a lambda function (follow this: https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#images-upload)
+Show the version of the application in a /version endpoint
+Testing with external dependencies
+Testing with internal state
+Testing updates
+    deploying lambda function (with state)
+    updating a container image? we should take care of transferring the state or reusing or whatever, always through the api of that state?
+Test deploying the application to kubernetes
+Use node version from nvmrc file (I think it is not needed as renovate will update the FROM version in the Dockerfile)
+Ensure we use the same commands to build the container for test and manually to debug
+Create a github action to share among all the repos
+Should we use docker-bench-security? seems like it is evaluating my host instead of the Dockerfile: https://github.com/docker/docker-bench-security
+Measure coverage from component tests
+Use docker containers also for dev environment
+Add tests for published docker images, is it needed?

package/adapters/Adapter.js

@@ -0,0 +1,5 @@
+module.exports = function(){
+    return Object.freeze({
+        
+    })
+}

package/adapters/AdapterThing.spec.js

@@ -0,0 +1,10 @@
+const Adapter = require('./Adapter')
+const Port = require('../domain/Thing.port')
+
+describe('Thing adapter', function(){
+    beforeEach(function(){
+        this.adapter = Adapter()
+    })
+
+    Port()
+})

package/cucumber.js

@@ -0,0 +1,3 @@
+module.exports = {
+    default: `--format progress --publish-quiet`,
+};

package/docker-compose.yml

@@ -0,0 +1,21 @@
+version: '3.8'
+
+services:
+  http-api:
+    container_name: "${CONTAINER_NAME:-api}"
+    image: http-api
+    build:
+      context: .
+      dockerfile: ./http-api/Dockerfile
+    ports:
+      - "3000:3000"
+    # I had to duplicate the healthcheck here and inside the Dockerfile
+    # because without defininfg the healthcheck here, when running compose up it was taking more than 30 seconds to be healthy
+    # while when running docker run directly the container was ready in 2 seconds
+    # also when running compose up with this healthcheck defined it takes only 2 seconds
+    healthcheck:
+      test: ["CMD", "node", "./http-api/healthcheck.js"]
+      interval: 1s
+      timeout: 20s
+      retries: 5
+      start_period: 1s

package/domain/Thing.port.js

@@ -0,0 +1,5 @@
+module.exports = function(){
+    describe('Thing port', function(){
+        it('must check adapter stuff')
+    })
+}

package/domain/calculator.js

@@ -0,0 +1,9 @@
+module.exports = function(){
+    return Object.freeze({
+        sum
+    })
+
+    function sum(){
+        return 3
+    }
+}

package/domain/domain.spec.js

@@ -0,0 +1,14 @@
+/**
+    This file is the entry point for the domain tests.
+    It mainly defines what is the user interface that we are going to use to test the domain.
+    
+    In this case it is the javascript-user-interface.
+    It will run all the tests that we have defined.
+**/
+
+const test_all = require('./test-cases/all')
+const domain_user_interface = require('./javascript-user-interface')()
+
+describe('Domain tests', function(){
+    test_all(domain_user_interface)
+})

package/domain/javascript-user-interface.js

@@ -0,0 +1,22 @@
+/**
+    This is one of the multiple user interfaces that the application could have.
+    User interfaces translate user actions into operations over the system through the specific interface.
+    
+    The user wants to sum two numbers and we translate that into the instantiation and usage of the calculator.
+    An http-api user interface would translate the same action into an http call.
+**/
+
+//TODO: Actually we could replace this one by a package-user-interface and require the index.js file instead of the calculator directly.
+const Calculator = require("./calculator")
+
+module.exports = function(){
+
+    const calculator = Calculator()
+    return Object.freeze({
+        sum
+    })
+
+    function sum(a, b){
+        return calculator.sum(a,b)
+    }
+}

package/domain/test-cases/all.js

@@ -0,0 +1,5 @@
+module.exports = function(user_interface){
+    describe('Domain tests', function(){
+        require('./sum.js')(user_interface)
+    })
+}

package/domain/test-cases/sum.js

@@ -0,0 +1,26 @@
+/**
+    In this file we describe the tests in terms of user actions and expectations.
+    We could also talk about situations in the the environment that can't be affected by the user like "today is Monday".
+**/
+
+
+const {expect} = require('chai');
+const User = require('./test-user.js');
+
+module.exports = function(user_interface){
+    describe('sum', function(){
+        let user
+
+        this.beforeEach(async function(){
+            user = User(user_interface)
+        })
+
+        it('basic sum', async () => {
+            let result = await user.sum(1,2)
+            expect(result).to.equal(3);
+        });
+
+
+        it('sum property based'); //https://github.com/dubzzz/fast-check/blob/main/packages/fast-check/documentation/Arbitraries.md#combinators
+    })
+}

package/domain/test-cases/test-user.js

@@ -0,0 +1,22 @@
+/**
+    This is the user that performs the test.
+    It receives a user interface which is the one it will use for testing.
+    It doesn't know what interface it is using, that specificities will go in the user interface.
+    It is aware of:
+        the operations that are needed to be performed on the interface
+        the time it takes to get the results
+        the errors generated
+        all the information that is only known by the user that could be relevant for the testing, like (credentials, name, age ... )
+        
+    We can add specific user expectations here regarding the error messages or the time it takes to get the results
+**/
+
+module.exports = function(user_interface){
+    return Object.freeze({
+        sum
+    })
+
+    async function sum(a, b){
+        return await user_interface.sum(a, b)
+    }
+}

package/features/simple_math.feature

@@ -0,0 +1,37 @@
+# features/simple_math.feature
+Feature: Simple maths
+  In order to do maths
+  As a developer
+  I want to increment variables
+
+  Scenario: increment
+    Given a variable set to 1
+    When I increment the variable by 1
+    Then the variable should contain 2
+
+  Scenario Outline: much more complex increment stuff
+    Given a variable set to <var>
+    When I increment the variable by <increment>
+    Then the variable should contain <result>
+
+    Examples:
+      | var | increment | result |
+      | 100 |         5 |    105 |
+      |  99 |      1234 |   1333 |
+      |  12 |         5 |     17 |
+
+  Scenario: decrement
+    Given a variable set to 1
+    When I decrement the variable by 1
+    Then the variable should contain 0
+
+  Scenario Outline: much more complex decrement stuff
+    Given a variable set to <var>
+    When I decrement the variable by <decrement>
+    Then the variable should contain <result>
+
+    Examples:
+      | var | decrement | result |
+      | 100 |         5 |     95 |
+      |  99 |      1234 |  -1135 |
+      |  12 |         5 |      7 |

package/features/support/steps.js

@@ -0,0 +1,15 @@
+// features/support/steps.js
+const { Given, When, Then } = require('@cucumber/cucumber')
+const { expect } = require('chai')
+
+Given('a variable set to {int}', function (number) {
+  this.setTo(number)
+})
+
+When('I {operation} the variable by {int}', function (operation, number) {
+  operation.call(this, number)
+})
+
+Then('the variable should contain {int}', function (number) {
+  expect(this.variable).to.eql(number)
+})

package/features/support/transform.js

@@ -0,0 +1,16 @@
+const {defineParameterType} = require('@cucumber/cucumber')
+
+defineParameterType({
+  regexp: /increment|decrement/,
+  transformer: function (operationId) {
+    switch (operationId) {
+      case 'increment':
+        return this.incrementBy
+      case 'decrement':
+        return this.decrementBy
+      default:
+        throw new Error(`Operation ${operationId} not supported`)
+    }
+  },
+  name: 'operation'
+})

package/features/support/world.js

@@ -0,0 +1,22 @@
+// features/support/world.js
+const { setWorldConstructor } = require('@cucumber/cucumber')
+
+class CustomWorld {
+  constructor () {
+    this.variable = 0
+  }
+
+  setTo (number) {
+    this.variable = number
+  }
+
+  incrementBy (number) {
+    this.variable += number
+  }
+
+  decrementBy (number) {
+    this.variable -= number
+  }
+}
+
+setWorldConstructor(CustomWorld)

package/http-api/Dockerfile

@@ -0,0 +1,21 @@
+FROM node:20.8.0
+
+# Update npm
+RUN npm i -g npm@9.6.5
+
+# Copy logic and http-api files
+COPY ./http-api ./http-api
+COPY ./domain ./domain
+COPY ./package.json ./package.json
+COPY ./package-lock.json ./package-lock.json
+
+# Install dependencies
+RUN npm i
+
+# Change to a non root user
+USER node
+
+# Start api on run
+CMD [ "node", "./http-api/start.js" ]
+
+HEALTHCHECK --interval=1s --timeout=1s --retries=5 CMD [ "node", "healthcheck.js" ]

package/http-api/healthcheck.js

@@ -0,0 +1,36 @@
+const http = require('http');
+
+const options = {
+  hostname: 'localhost',
+  port: 3000,
+  path: '/health',
+  method: 'GET',
+  timeout: 500,
+};
+
+console.log("healthcheck")
+
+const request = http.request(options, (res) => {
+    console.log('response')
+  if (res.statusCode === 200) {
+    console.log('OK')
+    process.exit(0);
+  } else {
+    console.log('not OK', res.statusCode)
+    process.exit(1);
+  }
+});
+
+request.on('error', () => {
+    console.log('error')
+  process.exit(1);
+});
+
+request.on('timeout', () => {
+    console.log('timeout')
+  request.destroy();
+  process.exit(1);
+});
+
+console.log("requesting...")
+request.end();

package/http-api/start.js

@@ -0,0 +1,26 @@
+const calculator = require('../domain/calculator')();
+
+const express = require('express');
+const PORT = process.env.PORT || 3000;
+
+const app = express();
+app.disable("x-powered-by"); //Disabled for security reasons. See: https://sonarcloud.io/organizations/unsegnor/rules?open=javascript%3AS5689&rule_key=javascript%3AS5689
+
+app.get('/helloworld', (req, res) => {
+  res.send('Hello World!');
+});
+
+app.get('/sum', (req, res) => {
+  const a = parseInt(req.query.a);
+  const b = parseInt(req.query.b);
+  const result = calculator.sum(a, b);
+  res.status(200).send(result.toString());
+});
+
+app.get('/health', (req, res) => {
+  res.status(200).send('OK');
+});
+
+app.listen(PORT, () => {
+  console.log(`Server running on port ${PORT}`);
+});

package/lambda-function/Dockerfile

@@ -0,0 +1,16 @@
+FROM public.ecr.aws/lambda/nodejs:18
+
+# Update npm
+RUN npm i -g npm@9.6.5
+
+# Copy your function's source code and package.json into the container following indications from the AWS Lambda documentation
+# https://docs.aws.amazon.com/lambda/latest/dg/images-create.html#images-create-1
+#TODO: could we use a command to reference the files when testing and copying them when running in production?
+COPY ./domain ${LAMBDA_TASK_ROOT}/domain
+COPY ./lambda-function/app.js package.json ${LAMBDA_TASK_ROOT}/
+
+# Install NPM dependencies
+RUN npm install
+
+# Set the Lambda function handler as the entry point
+CMD [ "app.handler" ]

package/lambda-function/app.js

@@ -0,0 +1,8 @@
+const AWS = require('aws-sdk');
+const Calculator = require('./domain/calculator');
+
+exports.handler = async (event) => {
+    const calculator = Calculator();
+    let result = await calculator.sum(event.a, event.b);
+    return result
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "auto-tdd",
+  "version": "0.1.3",
+  "description": "Automated development with TDD",
+  "main": "index.js",
+  "dockerHubUsername": "vcalatayud",
+  "devDependencies": {
+    "@cucumber/cucumber": "^10.0.0",
+    "@stryker-mutator/core": "6.4.2",
+    "@stryker-mutator/mocha-runner": "7.0.0",
+    "chai": "4.3.10",
+    "mocha": "10.2.0",
+    "uuid": "^9.0.0"
+  },
+  "scripts": {
+    "test": "npm run test-mocha && npm run test-cucumber && npm run test-api && npm run test-lambda",
+    "test-mocha": "npm run test-doubles && npm run test-domain && npm run test-adapters && npm run test-integration && npm run test-mutation",
+    "test-domain": "mocha domain --recursive",
+    "test-doubles": "mocha test-doubles --recursive",
+    "test-adapters": "mocha adapters --recursive",
+    "test-integration": "mocha test-integration --recursive",
+    "test-api": "npm run build-api-image && CONTAINER_NAME=api-auto-test-container && mocha test-http-api --recursive",
+    "test-lambda": "npm run build-lambda-image && CONTAINER_NAME=lambda-auto-test-container && mocha test-lambda-function --recursive",
+    "build-lambda-image": "docker build -t lambda-test-image -f ./lambda-function/Dockerfile .",
+    "test-mutation": "npx stryker run",
+    "test-cucumber": "cucumber-js",
+    "local-api": "node ./http-api/start.js",
+    "build-api-image": "docker build -t api-test-image -f ./http-api/Dockerfile .",
+    "api-container": "npm run build-api-image && docker run -d -p 3000:3000 --name api-test-container api-test-image",
+    "api-container-logs": "docker logs api-test-container",
+    "container-app": "CONTAINER_NAME=dev-api && docker-compose up -d --wait",
+    "remove-api-container": "docker rm -f api-test-container"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unsegnor/auto-tdd.git"
+  },
+  "keywords": [
+    "New",
+    "app",
+    "test",
+    "BDD",
+    "gherkins",
+    "cucumber",
+    "CI"
+  ],
+  "author": "Víctor Calatayud Asensio",
+  "license": "GPL-3.0-or-later",
+  "bugs": {
+    "url": "https://github.com/unsegnor/auto-tdd/issues"
+  },
+  "homepage": "https://github.com/unsegnor/auto-tdd#readme",
+  "dependencies": {
+    "aws-sdk": "^2.1363.0",
+    "axios": "^1.3.5",
+    "express": "^4.18.2"
+  }
+}

package/publish-on-docker-hub.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+build_and_push_image() {
+  FOLDER=$1
+  VERSION=$(node -p "require('./package.json').version")
+  APP_NAME=$(node -p "require('./package.json').name")
+  DOCKERHUB_USERNAME=$(node -p "require('./package.json').dockerHubUsername")
+  IMAGE_NAME="$DOCKERHUB_USERNAME/$APP_NAME-$FOLDER:$VERSION"
+  docker build -t $IMAGE_NAME -f ./$FOLDER/Dockerfile . 
+  docker push $IMAGE_NAME
+}
+
+build_and_push_image "$1"

package/renovate.json

@@ -0,0 +1,4 @@
+{
+  "automerge": true,
+  "nvm": true
+}

package/stryker.conf.js

@@ -0,0 +1,13 @@
+module.exports = {
+    packageManager: "npm",
+    reporters: ["clear-text", "progress"],
+    testRunner: "mocha",
+    coverageAnalysis: "perTest",
+    mochaOptions:{
+      spec: ['domain/*.spec.js']
+    },
+    mutate: ['domain/*.js',
+      '!domain/*.spec.js',
+      '!domain/*.port.js',
+      '!domain/*.factory.js']
+}

package/test-doubles/FakeThing.spec.js

@@ -0,0 +1,3 @@
+describe('Fake Thing', function(){
+    it('must behave as a thing')
+})

package/test-http-api/container-test-cases.js

@@ -0,0 +1,19 @@
+const runCommand = require('./runCommand');
+const delay = require('./delay');
+
+module.exports = function({baseUrl}){
+    describe('container tests', function(){
+        it('should build and run the container', () => {});
+    
+        it('should run containers in parallel')
+      
+        xit('play with the container before removing it', async () => {
+          console.log("container deployed")
+          await delay(60000)
+        });
+      
+        it('container is up and running', async () => {
+          await runCommand(`curl ${baseUrl}/health`, 'check api health')
+        });
+    })
+}

package/test-http-api/delay.js

@@ -0,0 +1,3 @@
+module.exports = function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/test-http-api/docker-compose.component.spec.js

@@ -0,0 +1,33 @@
+const uuid = require('uuid');
+const runCommand = require('./runCommand');
+const container_test_cases = require('./container-test-cases');
+const domain_tests = require('../domain/test-cases/all.js');
+const baseUrl = "http://localhost:3000"
+const http_user_interface = require('./http-api-user-interface')({baseUrl})
+
+describe('Docker compose container test', function () {
+  this.timeout(300000);
+
+    async function startApp(containerId){
+        await runCommand(`export CONTAINER_NAME=${containerId} && docker-compose up -d --build --wait`, `composed application ${containerId}`)
+    }
+
+    async function removeApp(containerId){
+        await runCommand(`export CONTAINER_NAME=${containerId} && docker-compose down`, `application removed ${containerId}`)
+    }
+
+  before(async () => { //beforeAll
+    this.containerId = uuid.v4()
+    await startApp(this.containerId)
+  });
+
+  after(async () => { //afterAll
+    await removeApp(this.containerId)
+  });
+
+  container_test_cases({baseUrl});
+
+  //TODO: pass a testscenario with preArrange, postArrange, preAct, postAct, preAssert, postAssert methods
+  //also user interface and later other options to mock dependencies
+  domain_tests(http_user_interface);
+});

package/test-http-api/docker.component.spec.js

@@ -0,0 +1,40 @@
+const uuid = require('uuid');
+const container_test_cases = require('./container-test-cases');
+const runCommand = require('./runCommand');
+const delay = require('./delay');
+const domain_tests = require('../domain/test-cases/all.js');
+const baseUrl = "http://localhost:3000"
+const http_user_interface = require('./http-api-user-interface')({baseUrl})
+
+describe('Docker container test', function () {
+  this.timeout(300000);
+
+    async function buildImage(){
+        await runCommand('docker build -t auto-test-image -f ./http-api/Dockerfile .', 'built image auto-test-image')
+    }
+
+    async function runContainer(containerId){
+        await runCommand(`docker run -d -p 3000:3000 --name ${containerId} auto-test-image`, `created container ${containerId}`)
+        await delay(1000) //TODO add this wait to the create command
+        // await runCommand(`docker logs ${containerId}`, `logs for container ${containerId}: \n`) //TODO: show the logs and fail in case there are errors
+    }
+
+    async function removeContainer(containerId){
+        await runCommand(`docker rm -f ${containerId}`, `removed container ${containerId}`)
+    }
+
+  before(async () => { //beforeAll
+    this.containerId = uuid.v4()
+    await buildImage()
+    await runContainer(this.containerId)
+  });
+
+  after(async () => { //afterAll
+    await removeContainer(this.containerId)
+  });
+
+  container_test_cases({baseUrl});
+
+  //TODO: pass a testscenario with preArrange, postArrange, preAct, postAct, preAssert, postAssert methods
+  domain_tests(http_user_interface);
+});

package/test-http-api/http-api-user-interface.js

@@ -0,0 +1,12 @@
+const axios = require('axios');
+
+module.exports = function({baseUrl}){
+    return Object.freeze({
+        sum
+    })
+
+    async function sum(a, b){
+        const response = await axios.get(`${baseUrl}/sum?a=${a}&b=${b}`);
+        return response.data
+    }
+}

package/test-http-api/runCommand.js

@@ -0,0 +1,12 @@
+const { exec } = require('child_process');
+
+module.exports = async function runCommand(command, reason){
+    return new Promise((resolve, reject) => {
+        exec(command, (error, stdout) => {
+            if (error) return reject(error)
+            //console.log(reason)
+            //console.log(stdout)
+            resolve();
+          });
+    })
+}

package/test-integration/TestingThingDoesStuff.spec.js

@@ -0,0 +1,3 @@
+describe('Thing does stuff', function(){
+    it('must do integration stuff')
+})

package/test-lambda-function/delay.js

@@ -0,0 +1,3 @@
+module.exports = function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}