Allow for pending and skipped tests (#25)

* Allow for pending and skipped tests

* Remove logging

* Add propper skip test

Author: SleeplessByte

CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 2.1.0
+
+- Allow skipping/pending tests (`test.skip`)
+
 ## 2.0.3
 
 - Disable compilation of `.test.ts` files when running in test-runner

package.json

@@ -2,7 +2,7 @@
   "name": "@exercism/typescript-test-runner",
   "description": "Automated Test runner for exercism solutions in TypeScript.",
   "author": "Derk-Jan Karrenbeld <[email protected]>",
-  "version": "2.0.3",
+  "version": "2.1.0",
   "license": "AGPL-3.0-or-later",
   "repository": {
     "type": "git",

src/output.ts

@@ -51,7 +51,11 @@ export class Output {
       this.results.status =
         aggregatedResults.numRuntimeErrorTestSuites === 0 &&
         aggregatedResults.numFailedTestSuites === 0 &&
-        aggregatedResults.numPendingTests === 0 &&
+        // Pending tests are skipped tests. test.skip tests are fine in our
+        // reporter and should not be forced to have ran here. So the next
+        // line is commented out.
+        //
+        // aggregatedResults.numPendingTests === 0 &&
         aggregatedResults.numFailedTests === 0
           ? 'pass'
           : 'fail'
@@ -279,16 +283,20 @@ function buildTestOutput(
     ]
   }
 
-  return inner.map((assert) => {
-    return {
-      name: assert.ancestorTitles.concat(assert.title).join(' > '),
-      status: assert.status === 'passed' ? 'pass' : 'fail',
-      message: sanitizeErrorMessage(
-        testResult.testFilePath,
-        assert.failureMessages.map(removeStackTrace).join('\n')
-      ),
-    }
-  })
+  return inner
+    .filter(
+      (assert) => assert.status !== 'skipped' && assert.status !== 'pending'
+    )
+    .map((assert) => {
+      return {
+        name: assert.ancestorTitles.concat(assert.title).join(' > '),
+        status: assert.status === 'passed' ? 'pass' : 'fail',
+        message: sanitizeErrorMessage(
+          testResult.testFilePath,
+          assert.failureMessages.map(removeStackTrace).join('\n')
+        ),
+      }
+    })
 }
 
 function removeStackTrace(message: string): string {

test/fixtures/pythagorean-triplet/chroth7/.docs/instructions.md

@@ -0,0 +1,24 @@
+# Instructions
+
+A Pythagorean triplet is a set of three natural numbers, {a, b, c}, for
+which,
+
+```text
+a**2 + b**2 = c**2
+```
+
+and such that,
+
+```text
+a < b < c
+```
+
+For example,
+
+```text
+3**2 + 4**2 = 9 + 16 = 25 = 5**2.
+```
+
+Given an input integer N, find all Pythagorean triplets for which `a + b + c = N`.
+
+For example, with N = 1000, there is exactly one Pythagorean triplet for which `a + b + c = 1000`: `{200, 375, 425}`.

test/fixtures/pythagorean-triplet/chroth7/.eslintignore

@@ -0,0 +1,12 @@
+!.meta
+
+# Protected or generated
+.git
+.vscode
+
+# When using npm
+node_modules/*
+
+# Configuration files
+babel.config.js
+jest.config.js

test/fixtures/pythagorean-triplet/chroth7/.eslintrc

@@ -0,0 +1,23 @@
+{
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "project": "./tsconfig.json",
+    "ecmaFeatures": {
+      "jsx": true
+    },
+    "ecmaVersion": 2020,
+    "sourceType": "module"
+  },
+  "extends": "@exercism/eslint-config-typescript",
+  "env": {
+    "jest": true
+  },
+  "overrides": [
+    {
+      "files": [".meta/proof.ci.ts", ".meta/exemplar.ts", "*.test.ts"],
+      "excludedFiles": ["custom.test.ts"],
+      "extends": "@exercism/eslint-config-typescript/maintainers"
+    }
+  ]
+}

test/fixtures/pythagorean-triplet/chroth7/.meta/config.json

@@ -0,0 +1,12 @@
+{
+  "blurb": "There exists exactly one Pythagorean triplet for which a + b + c = 1000. Find the product a * b * c.",
+  "authors": ["mdowds"],
+  "contributors": ["masters3d", "mdmower", "SleeplessByte"],
+  "files": {
+    "solution": ["pythagorean-triplet.ts"],
+    "test": ["pythagorean-triplet.test.ts"],
+    "example": [".meta/proof.ci.ts"]
+  },
+  "source": "Problem 9 at Project Euler",
+  "source_url": "http://projecteuler.net/problem=9"
+}

test/fixtures/pythagorean-triplet/chroth7/.meta/proof.ci.ts

@@ -0,0 +1,52 @@
+type Options = {
+  minFactor?: number
+  maxFactor?: number
+  sum: number
+}
+
+type TripletArray = [number, number, number]
+
+class Triplet {
+  constructor(
+    private readonly a: TripletArray[0],
+    private readonly b: TripletArray[1],
+    private readonly c: TripletArray[2]
+  ) {}
+
+  public toArray(): TripletArray {
+    return [this.a, this.b, this.c]
+  }
+
+  public get pythagorean(): boolean {
+    return this.a * this.a + this.b * this.b === this.c * this.c
+  }
+
+  public get sum(): number {
+    return this.a + this.b + this.c
+  }
+}
+
+export function triplets({ minFactor, maxFactor, sum }: Options): Triplet[] {
+  const min = minFactor || 1
+  const max = maxFactor || sum - 1
+
+  const isDesired = (triplet: Triplet): boolean => {
+    return triplet.pythagorean && (!sum || triplet.sum === sum)
+  }
+
+  const result: Triplet[] = []
+
+  for (let a = min; a < max - 1; a += 1) {
+    for (let b = a + 1; b < max; b += 1) {
+      for (let c = b + 1; c <= max; c += 1) {
+        const triplet = new Triplet(a, b, c)
+
+        if (isDesired(triplet)) {
+          result.push(triplet)
+        }
+      }
+    }
+  }
+
+  return result
+}

test/fixtures/pythagorean-triplet/chroth7/.meta/tests.toml

@@ -0,0 +1,24 @@
+# This is an auto-generated file. Regular comments will be removed when this
+# file is regenerated. Regenerating will not touch any manually added keys,
+# so comments can be added in a "comment" key.
+
+[a19de65d-35b8-4480-b1af-371d9541e706]
+description = "triplets whose sum is 12"
+
+[48b21332-0a3d-43b2-9a52-90b2a6e5c9f5]
+description = "triplets whose sum is 108"
+
+[dffc1266-418e-4daa-81af-54c3e95c3bb5]
+description = "triplets whose sum is 1000"
+
+[5f86a2d4-6383-4cce-93a5-e4489e79b186]
+description = "no matching triplets for 1001"
+
+[bf17ba80-1596-409a-bb13-343bdb3b2904]
+description = "returns all matching triplets"
+
+[9d8fb5d5-6c6f-42df-9f95-d3165963ac57]
+description = "several matching triplets"
+
+[f5be5734-8aa0-4bd1-99a2-02adcc4402b4]
+description = "triplets for large number"

test/fixtures/pythagorean-triplet/chroth7/babel.config.js

@@ -0,0 +1,20 @@
+module.exports = {
+  presets: [
+    [
+      '@babel/preset-env',
+      {
+        targets: {
+          node: 'current',
+        },
+        useBuiltIns: 'entry',
+        corejs: '3.17',
+      },
+    ],
+    '@babel/preset-typescript',
+  ],
+  plugins: [
+    '@babel/proposal-class-properties',
+    '@babel/proposal-object-rest-spread',
+    '@babel/plugin-syntax-bigint',
+  ],
+}

test/fixtures/pythagorean-triplet/chroth7/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+  verbose: true,
+  projects: ['<rootDir>'],
+  testMatch: [
+    '**/__tests__/**/*.[jt]s?(x)',
+    '**/test/**/*.[jt]s?(x)',
+    '**/?(*.)+(spec|test).[jt]s?(x)',
+  ],
+  testPathIgnorePatterns: [
+    '/(?:production_)?node_modules/',
+    '.d.ts$',
+    '<rootDir>/test/fixtures',
+    '<rootDir>/test/helpers',
+    '__mocks__',
+  ],
+  transform: {
+    '^.+\\.[jt]sx?$': 'babel-jest',
+  },
+}

test/fixtures/pythagorean-triplet/chroth7/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@exercism/typescript-pythagorean-triplet",
+  "version": "1.0.0",
+  "description": "Exercism exercises in Typescript.",
+  "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/exercism/typescript"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.15.5",
+    "@babel/plugin-proposal-class-properties": "^7.14.5",
+    "@babel/plugin-proposal-object-rest-spread": "^7.14.7",
+    "@babel/plugin-syntax-bigint": "^7.8.3",
+    "@babel/preset-env": "^7.15.4",
+    "@babel/preset-typescript": "^7.15.0",
+    "@types/jest": "^26.0.24",
+    "@types/node": "^14.17.14",
+    "@exercism/eslint-config-typescript": "^0.3.0",
+    "babel-jest": "^26.6.3",
+    "core-js": "^3.17.2",
+    "eslint": "^7.32.0",
+    "eslint-plugin-import": "^2.24.2",
+    "jest": "^26.6.3",
+    "typescript": "^4.4.2"
+  },
+  "scripts": {
+    "test": "yarn lint:types && jest --no-cache",
+    "lint": "yarn lint:types && yarn lint:ci",
+    "lint:types": "yarn tsc --noEmit -p .",
+    "lint:ci": "eslint . --ext .tsx,.ts"
+  }
+}

test/fixtures/pythagorean-triplet/chroth7/pythagorean-triplet.test.ts

@@ -0,0 +1,72 @@
+import { triplets } from './pythagorean-triplet'
+
+type Triplet = [number, number, number]
+
+function tripletsWithSum(sum: number, options = {}): Triplet[] {
+  return triplets({ ...options, sum }).map((triplet) =>
+    triplet.toArray().sort((a, b) => a - b)
+  )
+}
+
+describe('Triplet', () => {
+  test('triplets whose sum is 12', () => {
+    expect(tripletsWithSum(12)).toEqual([[3, 4, 5]])
+  })
+
+  test('triplets whose sum is 108', () => {
+    expect(tripletsWithSum(108)).toEqual([[27, 36, 45]])
+  })
+
+  test('triplets whose sum is 1000', () => {
+    expect(tripletsWithSum(1000)).toEqual([[200, 375, 425]])
+  })
+
+  test('no matching triplets for 1001', () => {
+    expect(tripletsWithSum(1001)).toEqual([])
+  })
+
+  test('returns all matching triplets', () => {
+    expect(tripletsWithSum(90)).toEqual([
+      [9, 40, 41],
+      [15, 36, 39],
+    ])
+  })
+
+  test('several matching triplets', () => {
+    expect(tripletsWithSum(840)).toEqual([
+      [40, 399, 401],
+      [56, 390, 394],
+      [105, 360, 375],
+      [120, 350, 370],
+      [140, 336, 364],
+      [168, 315, 357],
+      [210, 280, 350],
+      [240, 252, 348],
+    ])
+  })
+
+  test('returns triplets with no factor smaller than minimum factor', () => {
+    expect(tripletsWithSum(90, { minFactor: 10 })).toEqual([[15, 36, 39]])
+  })
+
+  test('returns triplets with no factor larger than maximum factor', () => {
+    expect(tripletsWithSum(840, { maxFactor: 349 })).toEqual([[240, 252, 348]])
+  })
+
+  test('returns triplets with factors in range', () => {
+    expect(tripletsWithSum(840, { maxFactor: 352, minFactor: 150 })).toEqual([
+      [210, 280, 350],
+      [240, 252, 348],
+    ])
+  })
+
+  test.skip('triplets for large number', () => {
+    expect(tripletsWithSum(30000)).toEqual([
+      [1200, 14375, 14425],
+      [1875, 14000, 14125],
+      [5000, 12000, 13000],
+      [6000, 11250, 12750],
+      [7500, 10000, 12500],
+    ])
+  })
+})