Changing front

front/app/node_modules/karma-jasmine/LICENSE

@@ -0,0 +1,20 @@
+The MIT License
+
+Copyright (C) 2011-2013 Google, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

front/app/node_modules/karma-jasmine/README.md

@@ -0,0 +1,112 @@
+# karma-jasmine
+
+[![npm version](https://img.shields.io/npm/v/karma-jasmine?style=flat-square)](https://www.npmjs.com/package/karma-jasmine)
+[![npm downloads](https://img.shields.io/npm/dm/karma-jasmine?style=flat-square)](https://www.npmjs.com/package/karma-jasmine)
+[![Release Workflow Status](https://img.shields.io/github/workflow/status/karma-runner/karma-jasmine/Release/master?style=flat-square&logo=github&label=Release)](https://github.com/karma-runner/karma-jasmine/actions/workflows/release.yml?query=branch%3Amaster)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen?style=flat-square)](https://github.com/karma-runner/karma-jasmine)
+[![semantic-release](https://img.shields.io/badge/%20%20%F0%9F%93%A6%F0%9F%9A%80-semantic--release-e10079?style=flat-square)](https://github.com/semantic-release/semantic-release)
+
+> Adapter for the [Jasmine](https://jasmine.github.io/) testing framework.
+
+## Installation
+
+```bash
+npm install karma-jasmine --save-dev
+```
+
+## Configuration
+
+```js
+// karma.conf.js
+module.exports = function(config) {
+  config.set({
+    frameworks: ['jasmine'],
+    files: [
+      '*.js'
+    ]
+  })
+}
+```
+
+If you want to run only some tests whose name match a given pattern you can do this in the following way
+
+```bash
+$ karma start &
+$ karma run -- --grep=<pattern>
+```
+
+where pattern is either a string (e.g `--grep=#slow` runs tests containing "#slow") or a Regex (e.g `--grep=/^(?!.*#slow).*$/` runs tests _not_ containing "#slow").
+
+You can also pass it to `karma.config.js`:
+
+```js
+module.exports = function(config) {
+  config.set({
+    // ...
+    client: {
+      args: ['--grep', '<pattern>'],
+      // ...
+    }
+  })
+}
+```
+
+If you want to pass configuration options directly to jasmine you can do this in the following way
+
+```js
+module.exports = function(config) {
+  config.set({
+    client: {
+      jasmine: {
+        random: true,
+        seed: '4321',
+        oneFailurePerSpec: true,
+        failFast: true,
+        timeoutInterval: 1000
+      }
+    }
+  })
+}
+```
+
+## Debug by URL
+
+Failing tests print a debug URL with `?spec=`. Use it with `--no_single_run`
+and paste it into your browser to focus on a single failing test.
+
+## Sharding
+
+By setting `config.client.shardIndex` and `config.client.totalShards`, you can
+run a subset of the full set of specs. Complete sharding support needs to be
+done in the process that calls karma, and would need to support test result
+integration across shards.
+
+## Custom spec filter
+
+Providing a [custom spec filter](https://jasmine.github.io/api/edge/Configuration#specFilter) is also supported.
+
+Example:
+
+```js
+// Users are able to set a custom specFilter themselves
+
+jasmine.getEnv().configure({
+  specFilter: function (spec) {
+    return spec.getFullName() === 'spec that succeeds'
+  }
+})
+
+describe('spec', () => {
+  it('that fails', () => {
+    fail('This spec should not run!')
+  })
+
+  it('that succeeds', () => {
+    expect(1).toBe(1)
+  })
+})
+```
+
+---
+
+For more information on Karma see the [homepage](https://karma-runner.github.io/).

front/app/node_modules/karma-jasmine/lib/adapter.js

@@ -0,0 +1,564 @@
+(function(window) {
+
+/* eslint no-unused-vars: ["error", { "varsIgnorePattern": "(createSpecFilter|createStartFn)" }] */
+
+'use strict'
+
+// Save link to native Date object
+// before it might be mocked by the user
+var _Date = Date
+
+/**
+ * Decision maker for whether a stack entry is considered external to jasmine and karma.
+ * @param  {String}  entry Error stack entry.
+ * @return {Boolean}       True if external, False otherwise.
+ */
+function isExternalStackEntry (entry) {
+  return !!entry &&
+  // entries related to jasmine and karma-jasmine:
+  !/\/(jasmine-core|karma-jasmine)\//.test(entry) &&
+  // karma specifics, e.g. "at http://localhost:7018/karma.js:185"
+  !/\/(karma.js|context.html):/.test(entry)
+}
+
+/**
+ * Returns relevant stack entries.
+ * @param  {Array} stack frames
+ * @return {Array}        A list of relevant stack entries.
+ */
+function getRelevantStackFrom (stack) {
+  var filteredStack = []
+  var relevantStack = []
+
+  for (var i = 0; i < stack.length; i += 1) {
+    if (isExternalStackEntry(stack[i])) {
+      filteredStack.push(stack[i])
+    }
+  }
+
+  // If the filtered stack is empty, i.e. the error originated entirely from within jasmine or karma, then the whole stack
+  // should be relevant.
+  if (filteredStack.length === 0) {
+    filteredStack = stack
+  }
+
+  for (i = 0; i < filteredStack.length; i += 1) {
+    if (filteredStack[i]) {
+      relevantStack.push(filteredStack[i])
+    }
+  }
+
+  return relevantStack
+}
+
+/**
+ * Custom formatter for a failed step.
+ *
+ * Different browsers report stack trace in different ways. This function
+ * attempts to provide a concise, relevant error message by removing the
+ * unnecessary stack traces coming from the testing framework itself as well
+ * as possible repetition.
+ *
+ * @see    https://github.com/karma-runner/karma-jasmine/issues/60
+ * @param  {Object} step Step object with stack and message properties.
+ * @return {String}      Formatted step.
+ */
+function formatFailedStep (step) {
+  var relevantMessage = []
+  var relevantStack = []
+
+  // Safari/Firefox seems to have no stack trace,
+  // so we just return the error message and if available
+  // construct a stacktrace out of filename and lineno:
+  if (!step.stack) {
+    if (step.filename) {
+      var stackframe = step.filename
+      if (step.lineno) {
+        stackframe = stackframe + ':' + step.lineno
+      }
+      relevantStack.push(stackframe)
+    }
+    relevantMessage.push(step.message)
+    return relevantMessage.concat(relevantStack).join('\n')
+  }
+
+  // Remove the message prior to processing the stack to prevent issues like
+  // https://github.com/karma-runner/karma-jasmine/issues/79
+  var stackframes = step.stack.split('\n')
+  var messageOnStack = null
+  if (stackframes[0].indexOf(step.message) !== -1) {
+    // Remove the message if it is in the stack string (eg Chrome)
+    messageOnStack = stackframes.shift()
+  }
+  // Filter frames
+  var relevantStackFrames = getRelevantStackFrom(stackframes)
+  if (messageOnStack) {
+    // Put the message back if we removed it.
+    relevantStackFrames.unshift(messageOnStack)
+  } else {
+    // The stack did not have the step.message so add it.
+    relevantStackFrames.unshift(step.message)
+  }
+
+  return relevantStackFrames.join('\n')
+}
+
+function debugUrl (description) {
+  // A link to re-run just one failed test case.
+  return window.location.origin + '/debug.html?spec=' + encodeURIComponent(description)
+}
+
+function SuiteNode (name, parent) {
+  this.name = name
+  this.parent = parent
+  this.children = []
+
+  this.addChild = function (name) {
+    var suite = new SuiteNode(name, this)
+    this.children.push(suite)
+    return suite
+  }
+}
+
+function processSuite (suite, pointer) {
+  var child
+  var childPointer
+
+  for (var i = 0; i < suite.children.length; i++) {
+    child = suite.children[i]
+
+    if (child.children) {
+      childPointer = pointer[child.description] = { _: [] }
+      processSuite(child, childPointer)
+    } else {
+      if (!pointer._) {
+        pointer._ = []
+      }
+      pointer._.push(child.description)
+    }
+  }
+}
+
+function getAllSpecNames (topSuite) {
+  var specNames = {}
+
+  processSuite(topSuite, specNames)
+
+  return specNames
+}
+
+/**
+ * Very simple reporter for Jasmine.
+ */
+function KarmaReporter (tc, jasmineEnv) {
+  var currentSuite = new SuiteNode()
+
+  var startTimeCurrentSpec = new _Date().getTime()
+
+  function handleGlobalErrors (result) {
+    if (result.failedExpectations && result.failedExpectations.length) {
+      var message = 'An error was thrown in afterAll'
+      var steps = result.failedExpectations
+      for (var i = 0, l = steps.length; i < l; i++) {
+        message += '\n' + formatFailedStep(steps[i])
+      }
+
+      tc.error(message)
+    }
+  }
+
+  /**
+   * Jasmine 2.0 dispatches the following events:
+   *
+   *  - jasmineStarted
+   *  - jasmineDone
+   *  - suiteStarted
+   *  - suiteDone
+   *  - specStarted
+   *  - specDone
+   */
+
+  this.jasmineStarted = function (data) {
+    // TODO(vojta): Do not send spec names when polling.
+    tc.info({
+      event: 'jasmineStarted',
+      total: data.totalSpecsDefined,
+      specs: getAllSpecNames(jasmineEnv.topSuite())
+    })
+  }
+
+  this.jasmineDone = function (result) {
+    result = result || {}
+
+    // Any errors in top-level afterAll blocks are given here.
+    handleGlobalErrors(result)
+
+    // Remove functions from called back results to avoid IPC errors in Electron
+    // https://github.com/twolfson/karma-electron/issues/47
+    var cleanedOrder
+    if (result.order) {
+      cleanedOrder = {}
+      var orderKeys = Object.getOwnPropertyNames(result.order)
+      for (var i = 0; i < orderKeys.length; i++) {
+        var orderKey = orderKeys[i]
+        if (typeof result.order[orderKey] !== 'function') {
+          cleanedOrder[orderKey] = result.order[orderKey]
+        }
+      }
+    }
+
+    tc.complete({
+      order: cleanedOrder,
+      coverage: window.__coverage__
+    })
+  }
+
+  this.suiteStarted = function (result) {
+    currentSuite = currentSuite.addChild(result.description)
+    tc.info({
+      event: 'suiteStarted',
+      result: result
+    })
+  }
+
+  this.suiteDone = function (result) {
+    // In the case of xdescribe, only "suiteDone" is fired.
+    // We need to skip that.
+    if (result.description !== currentSuite.name) {
+      return
+    }
+
+    // Any errors in afterAll blocks are given here, except for top-level
+    // afterAll blocks.
+    handleGlobalErrors(result)
+
+    currentSuite = currentSuite.parent
+
+    tc.info({
+      event: 'suiteDone',
+      result: result
+    })
+  }
+
+  this.specStarted = function () {
+    startTimeCurrentSpec = new _Date().getTime()
+  }
+
+  this.specDone = function (specResult) {
+    var skipped = specResult.status === 'disabled' || specResult.status === 'pending' || specResult.status === 'excluded'
+    var result = {
+      fullName: specResult.fullName,
+      description: specResult.description,
+      id: specResult.id,
+      log: [],
+      skipped: skipped,
+      disabled: specResult.status === 'disabled' || specResult.status === 'excluded',
+      pending: specResult.status === 'pending',
+      success: specResult.failedExpectations.length === 0,
+      suite: [],
+      time: skipped ? 0 : new _Date().getTime() - startTimeCurrentSpec,
+      executedExpectationsCount: specResult.failedExpectations.length + specResult.passedExpectations.length,
+      passedExpectations: specResult.passedExpectations,
+      properties: specResult.properties
+    }
+
+    // generate ordered list of (nested) suite names
+    var suitePointer = currentSuite
+    while (suitePointer.parent) {
+      result.suite.unshift(suitePointer.name)
+      suitePointer = suitePointer.parent
+    }
+
+    if (!result.success) {
+      var steps = specResult.failedExpectations
+      for (var i = 0, l = steps.length; i < l; i++) {
+        result.log.push(formatFailedStep(steps[i]))
+      }
+
+      if (typeof window !== 'undefined' && window.location && window.location.origin) {
+        // Report the name of fhe failing spec so the reporter can emit a debug url.
+        result.debug_url = debugUrl(specResult.fullName)
+      }
+    }
+
+    // When failSpecWithNoExpectations is true, Jasmine will report specs without expectations as failed
+    if (result.executedExpectationsCount === 0 && specResult.status === 'failed') {
+      result.success = false
+      result.log.push('Spec has no expectations')
+    }
+
+    tc.result(result)
+    delete specResult.startTime
+  }
+}
+
+/**
+ * Extract grep option from karma config
+ * @param {[Array|string]} clientArguments The karma client arguments
+ * @return {string} The value of grep option by default empty string
+ */
+var getGrepOption = function (clientArguments) {
+  var grepRegex = /^--grep=(.*)$/
+
+  if (Object.prototype.toString.call(clientArguments) === '[object Array]') {
+    var indexOfGrep = indexOf(clientArguments, '--grep')
+
+    if (indexOfGrep !== -1) {
+      return clientArguments[indexOfGrep + 1]
+    }
+
+    return map(filter(clientArguments, function (arg) {
+      return grepRegex.test(arg)
+    }), function (arg) {
+      return arg.replace(grepRegex, '$1')
+    })[0] || ''
+  } else if (typeof clientArguments === 'string') {
+    var match = /--grep=([^=]+)/.exec(clientArguments)
+
+    return match ? match[1] : ''
+  }
+}
+
+var createRegExp = function (filter) {
+  filter = filter || ''
+  if (filter === '') {
+    return new RegExp() // to match all
+  }
+
+  var regExp = /^[/](.*)[/]([gmixXsuUAJD]*)$/ // pattern to check whether the string is RegExp pattern
+
+  var parts = regExp.exec(filter)
+  if (parts === null) {
+    return new RegExp(filter.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, '\\$&')) // escape functional symbols
+  }
+
+  var patternExpression = parts[1]
+  var patternSwitches = parts[2]
+  return new RegExp(patternExpression, patternSwitches)
+}
+
+function getGrepSpecsToRun (clientConfig, specs) {
+  var grepOption = getGrepOption(clientConfig.args)
+  if (grepOption) {
+    var regExp = createRegExp(grepOption)
+    return filter(specs, function specFilter (spec) {
+      return regExp.test(spec.getFullName())
+    })
+  }
+}
+
+function parseQueryParams (location) {
+  var params = {}
+  if (location && Object.prototype.hasOwnProperty.call(location, 'search')) {
+    var pairs = location.search.slice(1).split('&')
+    for (var i = 0; i < pairs.length; i++) {
+      var keyValue = pairs[i].split('=')
+      params[decodeURIComponent(keyValue[0])] =
+          decodeURIComponent(keyValue[1])
+    }
+  }
+  return params
+}
+
+function getId (s) {
+  return s.id
+}
+
+function getSpecsByName (specs, name) {
+  specs = specs.filter(function (s) {
+    return s.name.indexOf(name) !== -1
+  })
+  if (specs.length === 0) {
+    throw new Error('No spec found with name: "' + name + '"')
+  }
+  return specs
+}
+
+function getDebugSpecToRun (location, specs) {
+  var queryParams = parseQueryParams(location)
+  var spec = queryParams.spec
+  if (spec) {
+    // A single spec has been requested by name for debugging.
+    return getSpecsByName(specs, spec)
+  }
+}
+
+function getSpecsToRunForCurrentShard (specs, shardIndex, totalShards) {
+  if (specs.length < totalShards) {
+    throw new Error(
+      'More shards (' + totalShards + ') than test specs (' + specs.length +
+      ')')
+  }
+
+  // Just do a simple sharding strategy of dividing the number of specs
+  // equally.
+  var firstSpec = Math.floor(specs.length * shardIndex / totalShards)
+  var lastSpec = Math.floor(specs.length * (shardIndex + 1) / totalShards)
+  return specs.slice(firstSpec, lastSpec)
+}
+
+function getShardedSpecsToRun (specs, clientConfig) {
+  var shardIndex = clientConfig.shardIndex
+  var totalShards = clientConfig.totalShards
+  if (shardIndex != null && totalShards != null) {
+    // Sharded mode - Run only the subset of the specs corresponding to the
+    // current shard.
+    return getSpecsToRunForCurrentShard(
+      specs, Number(shardIndex), Number(totalShards))
+  }
+}
+
+/**
+ * Create jasmine spec filter
+ * @param {Object} clientConfig karma config
+ * @param {!Object} jasmineEnv
+ */
+var KarmaSpecFilter = function (clientConfig, jasmineEnv) {
+  /**
+   * Walk the test suite tree depth first and collect all test specs
+   * @param {!Object} jasmineEnv
+   * @return {!Array<string>} All possible tests.
+   */
+  function getAllSpecs (jasmineEnv) {
+    var specs = []
+    var stack = [jasmineEnv.topSuite()]
+    var currentNode
+    while ((currentNode = stack.pop())) {
+      if (currentNode.children) {
+        // jasmine.Suite
+        stack = stack.concat(currentNode.children)
+      } else if (currentNode.id) {
+        // jasmine.Spec
+        specs.unshift(currentNode)
+      }
+    }
+
+    return specs
+  }
+
+  /**
+   * Filter the specs with URL search params and config.
+   * @param {!Object} location property 'search' from URL.
+   * @param {!Object} clientConfig karma client config
+   * @param {!Object} jasmineEnv
+   * @return {!Array<string>}
+   */
+  function getSpecsToRun (location, clientConfig, jasmineEnv) {
+    var specs = getAllSpecs(jasmineEnv).map(function (spec) {
+      spec.name = spec.getFullName()
+      return spec
+    })
+
+    if (!specs || !specs.length) {
+      return []
+    }
+
+    return getGrepSpecsToRun(clientConfig, specs) ||
+          getDebugSpecToRun(location, specs) ||
+          getShardedSpecsToRun(specs, clientConfig) ||
+          specs
+  }
+
+  this.specIdsToRun = new Set(getSpecsToRun(window.location, clientConfig, jasmineEnv).map(getId))
+
+  this.matches = function (spec) {
+    return this.specIdsToRun.has(spec.id)
+  }
+}
+
+/**
+ * Configure jasmine specFilter
+ *
+ * This function is invoked from the wrapper.
+ * @see  adapter.wrapper
+ *
+ * @param {Object} config The karma config
+ * @param {Object} jasmineEnv jasmine environment object
+ */
+var createSpecFilter = function (config, jasmineEnv) {
+  var karmaSpecFilter = new KarmaSpecFilter(config, jasmineEnv)
+
+  var originalSpecFilter = jasmineEnv.configuration().specFilter
+  var specFilter = function (spec) {
+    return originalSpecFilter(spec) && karmaSpecFilter.matches(spec)
+  }
+
+  return specFilter
+}
+
+/**
+ * Karma starter function factory.
+ *
+ * This function is invoked from the wrapper.
+ * @see  adapter.wrapper
+ *
+ * @param  {Object}   karma        Karma runner instance.
+ * @param  {Object}   [jasmineEnv] Optional Jasmine environment for testing.
+ * @return {Function}              Karma starter function.
+ */
+function createStartFn (karma, jasmineEnv) {
+  // This function will be assigned to `window.__karma__.start`:
+  return function () {
+    var clientConfig = karma.config || {}
+    var jasmineConfig = clientConfig.jasmine || {}
+
+    jasmineEnv = jasmineEnv || window.jasmine.getEnv()
+
+    jasmineConfig.specFilter = createSpecFilter(clientConfig, jasmineEnv)
+    jasmineEnv.configure(jasmineConfig)
+
+    window.jasmine.DEFAULT_TIMEOUT_INTERVAL = jasmineConfig.timeoutInterval ||
+      window.jasmine.DEFAULT_TIMEOUT_INTERVAL
+    jasmineEnv.addReporter(new KarmaReporter(karma, jasmineEnv))
+    jasmineEnv.execute()
+  }
+}
+
+function indexOf (collection, find, i /* opt */) {
+  if (collection.indexOf) {
+    return collection.indexOf(find, i)
+  }
+
+  if (i === undefined) { i = 0 }
+  if (i < 0) { i += collection.length }
+  if (i < 0) { i = 0 }
+  for (var n = collection.length; i < n; i++) {
+    if (i in collection && collection[i] === find) {
+      return i
+    }
+  }
+  return -1
+}
+
+function filter (collection, filter, that /* opt */) {
+  if (collection.filter) {
+    return collection.filter(filter, that)
+  }
+
+  var other = []
+  var v
+  for (var i = 0, n = collection.length; i < n; i++) {
+    if (i in collection && filter.call(that, v = collection[i], i, collection)) {
+      other.push(v)
+    }
+  }
+  return other
+}
+
+function map (collection, mapper, that /* opt */) {
+  if (collection.map) {
+    return collection.map(mapper, that)
+  }
+
+  var other = new Array(collection.length)
+  for (var i = 0, n = collection.length; i < n; i++) {
+    if (i in collection) {
+      other[i] = mapper.call(that, collection[i], i, collection)
+    }
+  }
+  return other
+}
+
+window.__karma__.start = createStartFn(window.__karma__)
+
+})(typeof window !== 'undefined' ? window : global);

front/app/node_modules/karma-jasmine/lib/boot.js

@@ -0,0 +1,43 @@
+/**
+ * Jasmine 2.0 standalone `boot.js` modified for Karma.
+ * This file is registered in `index.js`. This version
+ * does not include `HtmlReporter` setup.
+ */
+;(function (global) {
+  /* global jasmineRequire */
+  'use strict'
+
+  /**
+   * Require Jasmine's core files. Specifically, this requires and
+   * attaches all of Jasmine's code to the `jasmine` reference.
+   */
+  var jasmine = jasmineRequire.core(jasmineRequire)
+
+  /**
+   * Obtain the public Jasmine API.
+   */
+  var jasmineInterface = jasmineRequire.interface(jasmine, jasmine.getEnv())
+
+  /**
+   * Setting up timing functions to be able to be overridden.
+   * Certain browsers (Safari, IE 8, PhantomJS) require this hack.
+   */
+  /* eslint-disable no-self-assign */
+  global.setTimeout = global.setTimeout
+  global.setInterval = global.setInterval
+  global.clearTimeout = global.clearTimeout
+  global.clearInterval = global.clearInterval
+  /* eslint-enable no-self-assign */
+
+  /**
+   * Add all of the Jasmine global/public interface to the proper
+   * global, so a project can use the public interface directly.
+   * For example, calling `describe` in specs instead of
+   * `jasmine.getEnv().describe`.
+   */
+  for (var property in jasmineInterface) {
+    if (Object.prototype.hasOwnProperty.call(jasmineInterface, property)) {
+      global[property] = jasmineInterface[property]
+    }
+  }
+}(typeof window !== 'undefined' ? window : global))

front/app/node_modules/karma-jasmine/lib/index.js

@@ -0,0 +1,31 @@
+var path = require('path')
+
+var createPattern = function (pattern) {
+  return { pattern: pattern, included: true, served: true, watched: false }
+}
+
+var initJasmine = function (files) {
+  var jasminePath = path.dirname(require.resolve('jasmine-core'))
+  files.unshift(createPattern(path.join(__dirname, '/adapter.js')))
+  files.unshift(createPattern(path.join(__dirname, '/boot.js')))
+  files.unshift(createPattern(jasminePath + '/jasmine-core/jasmine.js'))
+}
+
+initJasmine.$inject = ['config.files']
+
+function InjectKarmaJasmineReporter (singleRun) {
+  return {
+    onSpecComplete (browser, karmaResult) {
+      if (!singleRun && karmaResult.debug_url) {
+        console.log('Debug this test: ' + karmaResult.debug_url)
+      }
+    }
+  }
+}
+
+InjectKarmaJasmineReporter.$inject = ['config.singleRun']
+
+module.exports = {
+  'framework:jasmine': ['factory', initJasmine],
+  'reporter:karma-jasmine': ['factory', InjectKarmaJasmineReporter]
+}

front/app/node_modules/karma-jasmine/package.json

@@ -0,0 +1,115 @@
+{
+  "name": "karma-jasmine",
+  "version": "5.1.0",
+  "description": "A Karma plugin - adapter for Jasmine testing framework.",
+  "main": "lib/index.js",
+  "files": [
+    "lib/*.js"
+  ],
+  "scripts": {
+    "build": "grunt build",
+    "lint": "eslint \"**/*.js\"",
+    "lint:fix": "eslint --fix \"**/*.js\"",
+    "commitlint": "commitlint",
+    "test": "npm run test:unit && npm run test:e2e && npm run test:integration",
+    "test:unit": "jasmine",
+    "test:e2e": "karma start karma.conf.js",
+    "test:integration": "bash tools/integration-tests.sh",
+    "release": "semantic-release"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/karma-runner/karma-jasmine.git"
+  },
+  "keywords": [
+    "karma-plugin",
+    "karma-adapter",
+    "jasmine"
+  ],
+  "author": "Vojta Jina <vojta.jina@gmail.com>",
+  "dependencies": {
+    "jasmine-core": "^4.1.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^16.2.3",
+    "@commitlint/config-angular": "^16.2.3",
+    "@semantic-release/changelog": "^6.0.1",
+    "@semantic-release/git": "^10.0.1",
+    "@semantic-release/github": "^8.0.4",
+    "@semantic-release/npm": "^9.0.1",
+    "eslint": "^7.32.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^5.2.0",
+    "eslint-plugin-standard": "^4.1.0",
+    "grunt": "^1.5.2",
+    "husky": "^4.3.8",
+    "jasmine": "^4.1.0",
+    "karma": "^6.3.18",
+    "karma-firefox-launcher": "^2.1.2",
+    "semantic-release": "^19.0.2"
+  },
+  "peerDependencies": {
+    "karma": "^6.0.0"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "husky": {
+    "hooks": {
+      "commit-msg": "commitlint -E HUSKY_GIT_PARAMS"
+    }
+  },
+  "license": "MIT",
+  "contributors": [
+    "Maksim Ryzhikov <rv.maksim@gmail.com>",
+    "johnjbarton <johnjbarton@johnjbarton.com>",
+    "Jonathan Ginsburg <jon@than.ml>",
+    "Mark Ethan Trostler <mark@zzo.com>",
+    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
+    "XhmikosR <xhmikosr@gmail.com>",
+    "olegskl <sklyanchuk@gmail.com>",
+    "semantic-release-bot <semantic-release-bot@martynus.net>",
+    "dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>",
+    "dignifiedquire <dignifiedquire@gmail.com>",
+    "Cornelius Schmale <github@cschmale.de>",
+    "Arthur Thornton <arthur@thestorefront.com>",
+    "Friedel Ziegelmayer <friedel.ziegelmayer@gmail.com>",
+    "Patrick McGuckin <patrick@gskinner.com>",
+    "Richard Park <objectiv@gmail.com>",
+    "Fernando Costa <fadc80@gmail.com>",
+    "Nico Jansen <jansennico@gmail.com>",
+    "Aaron Hartwig <aaron.hartwig@whyhigh.com>",
+    "Alesei N <github.com@bzik.net>",
+    "Barry Fitzgerald <barfitzgerald@gmail.com>",
+    "Dirk T <DirkToewe@GoogleMail.com>",
+    "Dmitriy Tychshenko <dtychshenko@users.noreply.github.com>",
+    "Flavian Hautbois <flavian@apricity.life>",
+    "Georgii Dolzhykov <thorn.mailbox@gmail.com>",
+    "Gregg Van Hove <gvanhove@pivotal.io>",
+    "Jacob Trimble <modmaker@google.com>",
+    "João Pereira <joaopapereira@gmail.com>",
+    "Keen Yee Liau <kyliau@google.com>",
+    "Limon Monte <limon.monte@gmail.com>",
+    "Luis Aleman <Lalem001@users.noreply.github.com>",
+    "Marek Vavrecan <vavrecan@gmail.com>",
+    "Matthew Hill <Matthew.Hill4@bskyb.com>",
+    "Milan Lempera <milanlempera@gmail.com>",
+    "Niels Dequeker <niels.dequeker@gmail.com>",
+    "Robin Gloster <robin@loc-com.de>",
+    "Sahat Yalkabov <sakhat@gmail.com>",
+    "Sampo Kivistö <sampo.kivisto@visma.com>",
+    "Schaaf, Martin <703355+mschaaf@users.noreply.github.com>",
+    "Sergey Tatarintsev <sevinf@yandex-team.ru>",
+    "Sid Vishnoi <sidvishnoi8@gmail.com>",
+    "Stefan Dragnev <dragnev@telerik.com>",
+    "Tobias Speicher <rootcommander@gmail.com>",
+    "Todd Wolfson <todd@twolfson.com>",
+    "Vladimir Belov <Vladimir.Belov@hotmail.com>",
+    "Yusuke Iinuma <yinm@users.noreply.github.com>",
+    "jiverson <jiverson222@gmail.com>",
+    "rpark <objectiv@gmail.com>",
+    "strille <strille@users.noreply.github.com>"
+  ]
+}