Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use actualAlternativeCode method in stryker-parent

Best JavaScript code snippet using stryker-parent

expression-mutant-placer.spec.ts

Source:expression-mutant-placer.spec.ts

1import { expect } from 'chai';2import { types, NodePath } from '@babel/core';3import { normalizeWhitespaces } from '@stryker-mutator/util';4import generate from '@babel/generator';5import { expressionMutantPlacer } from '../../../src/mutant-placers/expression-mutant-placer';6import { findNodePath, parseJS, parseTS } from '../../helpers/syntax-test-helpers';7import { Mutant } from '../../../src/mutant';8import { createMutant } from '../../helpers/factories';9describe('expressionMutantPlacer', () => {10  it('should have the correct name', () => {11    expect(expressionMutantPlacer.name).eq('expressionMutantPlacer');12  });13  describe(expressionMutantPlacer.canPlace.name, () => {14    it('should be true for an expression', () => {15      // Arrange16      const ast = parseJS('const foo = a + b');17      const binaryExpression = findNodePath(ast, (p) => p.isBinaryExpression());18      // Act19      const actual = expressionMutantPlacer.canPlace(binaryExpression);20      // Assert21      expect(actual).true;22    });23    it('should be false when the parent is tagged template expression', () => {24      // A templateLiteral is considered an expression, while it is not save to place a mutant there!25      const templateLiteral = findNodePath(parseJS('html`<p></p>`'), (p) => p.isTemplateLiteral());26      expect(expressionMutantPlacer.canPlace(templateLiteral)).false;27    });28    describe('object literals', () => {29      it('should be false when the expression is a key', () => {30        // A stringLiteral is considered an expression, while it is not save to place a mutant there!31        const stringLiteral = findNodePath(parseJS("const foo = { 'foo': bar }"), (p) => p.isStringLiteral());32        expect(expressionMutantPlacer.canPlace(stringLiteral)).false;33      });34      it('should be true when the expression is the value', () => {35        // A stringLiteral is considered an expression, while it is not save to place a mutant there!36        const stringLiteral = findNodePath(parseJS("const foo = { 'foo': bar }"), (p) => p.isIdentifier() && p.node.name === 'bar');37        expect(expressionMutantPlacer.canPlace(stringLiteral)).true;38      });39    });40    describe('chain expressions', () => {41      type ChainExpressionArrangement = [string, (path: NodePath) => boolean];42      const okPointers: ChainExpressionArrangement[] = [43        ['bar()', (p) => p.isCallExpression()],44        ['bar.foo', (p) => p.isMemberExpression()],45        ['bar.foo()', (p) => p.isCallExpression()],46        ['bar?.foo()', (p) => p.isOptionalCallExpression()],47        ['bar?.foo', (p) => p.isOptionalMemberExpression()],48        ['bar?.[1]', (p) => p.isOptionalMemberExpression()],49        ['bar[1]', (p) => p.isMemberExpression()],50        ['qux?.foo(bar());', (p) => p.isCallExpression() && types.isIdentifier(p.node.callee, { name: 'bar' })],51        ['foo(bar());', (p) => p.isCallExpression() && types.isIdentifier(p.node.callee, { name: 'bar' })],52        ['foo(bar.baz);', (p) => p.isMemberExpression() && types.isIdentifier(p.node.object, { name: 'bar' })],53      ];54      okPointers.forEach(([js, query]) => {55        it(`should allow placing in \`bar\` of \`${js}\``, () => {56          const path = findNodePath(parseJS(js), query);57          expect(expressionMutantPlacer.canPlace(path)).true;58        });59      });60      const falsePointers: ChainExpressionArrangement[] = [61        ['foo.bar.baz', (p) => p.isMemberExpression() && types.isIdentifier(p.node.property, { name: 'bar' })],62        ['foo.bar()', (p) => p.isMemberExpression() && types.isIdentifier(p.node.property, { name: 'bar' })],63        ['foo?.bar()', (p) => p.isOptionalMemberExpression() && types.isIdentifier(p.node.property, { name: 'bar' })],64        ['foo.bar?.baz', (p) => p.isMemberExpression() && types.isIdentifier(p.node.property, { name: 'bar' })],65        ['foo?.bar.baz', (p) => p.isOptionalMemberExpression() && types.isIdentifier(p.node.property, { name: 'bar' })],66        ['foo?.bar!.baz', (p) => p.isTSNonNullExpression()],67      ];68      falsePointers.forEach(([js, query]) => {69        it(`should not allow placing in \`bar\` of \`${js}\``, () => {70          const path = findNodePath(parseTS(js), query);71          expect(expressionMutantPlacer.canPlace(path)).false;72        });73      });74    });75  });76  describe(expressionMutantPlacer.place.name, () => {77    it('should be able to place a mutant on an expression', () => {78      // Arrange79      const { binaryExpression, appliedMutants, ast } = arrangeSingleMutant();80      // Act81      expressionMutantPlacer.place(binaryExpression, appliedMutants);82      const actualCode = normalizeWhitespaces(generate(ast).code);83      // Assert84      expect(actualCode).contains('const foo = stryMutAct_9fa48("1") ? bar >>> baz');85    });86    it('should place the original code as the alternative', () => {87      const { binaryExpression, appliedMutants, ast } = arrangeSingleMutant();88      expressionMutantPlacer.place(binaryExpression, appliedMutants);89      const actualAlternative = findNodePath<types.ConditionalExpression>(ast, (p) => p.isConditionalExpression()).node.alternate;90      const actualAlternativeCode = generate(actualAlternative).code;91      expect(actualAlternativeCode.endsWith('a + b'), `${actualAlternativeCode} did not end with "a + b"`).true;92    });93    it('should add mutant coverage syntax', () => {94      const { binaryExpression, appliedMutants, ast } = arrangeSingleMutant();95      expressionMutantPlacer.place(binaryExpression, appliedMutants);96      const actualAlternative = findNodePath<types.ConditionalExpression>(ast, (p) => p.isConditionalExpression()).node.alternate;97      const actualAlternativeCode = generate(actualAlternative).code;98      const expected = 'stryCov_9fa48("1"), a + b';99      expect(actualAlternativeCode.startsWith(expected), `${actualAlternativeCode} did not start with "${expected}"`).true;100    });101    it('should be able to place multiple mutants', () => {102      // Arrange103      const ast = parseJS('const foo = a + b');104      const binaryExpression = findNodePath<types.BinaryExpression>(ast, (p) => p.isBinaryExpression());105      const mutants = [106        createMutant({107          id: '52',108          original: binaryExpression.node,109          replacement: types.binaryExpression('-', types.identifier('bar'), types.identifier('baz')),110        }),111        createMutant({112          id: '659',113          original: binaryExpression.node,114          replacement: types.identifier('bar'),115        }),116      ];117      const appliedMutants = new Map<Mutant, types.BinaryExpression>([118        [mutants[0], mutants[0].applied(binaryExpression.node)],119        [mutants[1], mutants[1].applied(binaryExpression.node)],120      ] as const);121      // Act122      expressionMutantPlacer.place(binaryExpression, appliedMutants);123      const actualCode = normalizeWhitespaces(generate(ast).code);124      // Assert125      expect(actualCode).contains('const foo = stryMutAct_9fa48("659") ? bar : stryMutAct_9fa48("52") ? bar - baz');126    });127    function arrangeSingleMutant() {128      const ast = parseJS('const foo = a + b');129      const binaryExpression = findNodePath<types.BinaryExpression>(ast, (p) => p.isBinaryExpression());130      const mutant = new Mutant('1', 'file.js', binaryExpression.node, {131        replacement: types.binaryExpression('>>>', types.identifier('bar'), types.identifier('baz')),132        mutatorName: 'fooMutator',133      });134      const appliedMutants = new Map([[mutant, mutant.applied(binaryExpression.node)]]);135      return { binaryExpression, appliedMutants, ast };136    }137    /**138     * This describe has tests for anonymous classes and functions.139     * @see https://github.com/stryker-mutator/stryker-js/issues/2362140     */141    describe('anonymous expressions', () => {142      function arrangeActAssert(ast: types.File, expression: NodePath<types.Expression>, expectedMatch: RegExp) {143        const mutant = createMutant({144          id: '4',145          original: expression.node,146          replacement: types.identifier('bar'),147        });148        const appliedMutants = new Map([[mutant, mutant.applied(expression.node)]]);149        // Act150        expressionMutantPlacer.place(expression, appliedMutants);151        const actualCode = normalizeWhitespaces(generate(ast).code);152        // Assert153        expect(actualCode).matches(expectedMatch);154      }155      it('should set the name of an anonymous function expression', () => {156        // Arrange157        const ast = parseJS('const foo = function () { }');158        const functionExpression = findNodePath<types.FunctionExpression>(ast, (p) => p.isFunctionExpression());159        arrangeActAssert(ast, functionExpression, /const foo =.*function foo\(\) {}/);160      });161      it('should set the name of an anonymous method expression', () => {162        // Arrange163        const ast = parseJS('const foo = { bar: function () { } }');164        const functionExpression = findNodePath<types.FunctionExpression>(ast, (p) => p.isFunctionExpression());165        arrangeActAssert(ast, functionExpression, /const foo =.*bar:.*function bar\(\) {}/);166      });167      it('should not set the name if the statement is not a variable declaration', () => {168        // Arrange169        const ast = parseJS('foo.bar = function () { }');170        const functionExpression = findNodePath<types.FunctionExpression>(ast, (p) => p.isFunctionExpression());171        arrangeActAssert(ast, functionExpression, /foo\.bar =.*function \(\) {}/);172      });173      it('should not set the name of a named function expression', () => {174        // Arrange175        const ast = parseJS('const foo = function bar () { }');176        const functionExpression = findNodePath<types.FunctionExpression>(ast, (p) => p.isFunctionExpression());177        arrangeActAssert(ast, functionExpression, /const foo =.*function bar\(\) {}/);178      });179      it('should set the name of an anonymous class expression', () => {180        // Arrange181        const ast = parseJS('const Foo = class { }');182        const classExpression = findNodePath<types.ClassExpression>(ast, (p) => p.isClassExpression());183        arrangeActAssert(ast, classExpression, /const Foo =.*class Foo {}/);184      });185      it('should not override the name of a named class expression', () => {186        // Arrange187        const ast = parseJS('const Foo = class Bar { }');188        const classExpression = findNodePath<types.ClassExpression>(ast, (p) => p.isClassExpression());189        arrangeActAssert(ast, classExpression, /const Foo =.*class Bar {}/);190      });191      it('should set the name of an anonymous arrow function', () => {192        // Arrange193        const ast = parseJS('const bar = () => {}');194        const functionExpression = findNodePath<types.ArrowFunctionExpression>(ast, (p) => p.isArrowFunctionExpression());195        arrangeActAssert(ast, functionExpression, /const bar =.*\(\(\) => { const bar = \(\) => {}; return bar; }\)\(\)/);196      });197    });198  });...

Using AI Code Generation

1var strykerParent = require('stryker-parent');2console.log(strykerParent.actualAlternativeCode());3var strykerParent = require('stryker-parent');4console.log(strykerParent.actualAlternativeCode());5var strykerParent = require('stryker-parent');6console.log(strykerParent.actualAlternativeCode());7var strykerParent = require('stryker-parent');8console.log(strykerParent.actualAlternativeCode());9var strykerParent = require('stryker-parent');10console.log(strykerParent.actualAlternativeCode());11var strykerParent = require('stryker-parent');12console.log(strykerParent.actualAlternativeCode());13var strykerParent = require('stryker-parent');14console.log(strykerParent.actualAlternativeCode());15var strykerParent = require('stryker-parent');16console.log(strykerParent.actualAlternativeCode());17var strykerParent = require('stryker-parent');18console.log(strykerParent.actualAlternativeCode());19var strykerParent = require('stryker-parent');20console.log(strykerParent.actualAlternativeCode());21var strykerParent = require('stryker-parent');22console.log(strykerParent.actualAlternativeCode());23var strykerParent = require('stryker-parent');24console.log(strykerParent.actualAlternativeCode());

Using AI Code Generation

1const strykerParent = require('stryker-parent');2const actualAlternativeCode = strykerParent.actualAlternativeCode;3const strykerParent = require('stryker-parent');4const actualAlternativeCode = strykerParent.actualAlternativeCode;5const strykerParent = require('stryker-parent');6const actualAlternativeCode = strykerParent.actualAlternativeCode;7const strykerParent = require('stryker-parent');8const actualAlternativeCode = strykerParent.actualAlternativeCode;9const strykerParent = require('stryker-parent');10const actualAlternativeCode = strykerParent.actualAlternativeCode;11const strykerParent = require('stryker-parent');12const actualAlternativeCode = strykerParent.actualAlternativeCode;13const strykerParent = require('stryker-parent');14const actualAlternativeCode = strykerParent.actualAlternativeCode;15const strykerParent = require('stryker-parent');16const actualAlternativeCode = strykerParent.actualAlternativeCode;17const strykerParent = require('stryker-parent');18const actualAlternativeCode = strykerParent.actualAlternativeCode;19const strykerParent = require('stryker-parent');20const actualAlternativeCode = strykerParent.actualAlternativeCode;21const strykerParent = require('stryker-parent');22const actualAlternativeCode = strykerParent.actualAlternativeCode;23const strykerParent = require('stryker-parent');24const actualAlternativeCode = strykerParent.actualAlternativeCode;

Using AI Code Generation

1const {actualAlternativeCode} = require('stryker-parent');2actualAlternativeCode();3const {actualAlternativeCode} = require('stryker-parent');4actualAlternativeCode();5const {actualAlternativeCode} = require('stryker-parent');6actualAlternativeCode();7const {actualAlternativeCode} = require('stryker-parent');8actualAlternativeCode();9const {actualAlternativeCode} = require('stryker-parent');10actualAlternativeCode();11const {actualAlternativeCode} = require('stryker-parent');12actualAlternativeCode();13const {actualAlternativeCode} = require('stryker-parent');14actualAlternativeCode();15const {actualAlternativeCode} = require('stryker-parent');16actualAlternativeCode();17const {actualAlternativeCode} = require('stryker-parent');18actualAlternativeCode();19const {actualAlternativeCode} = require('stryker-parent');20actualAlternativeCode();21const {actualAlternativeCode} = require('stryker-parent');22actualAlternativeCode();23const {actualAlternativeCode} = require('stryker-parent');24actualAlternativeCode();25const {actualAlternativeCode} = require('stryker-parent');26actualAlternativeCode();27const {actualAlternativeCode} = require('stryker-parent');28actualAlternativeCode();

Using AI Code Generation

1var strykerParent = require('stryker-parent');2var actualAlternativeCode = strykerParent.actualAlternativeCode;3console.log(actualAlternativeCode('test'));4var strykerParent = require('stryker-parent');5var actualAlternativeCode = strykerParent.actualAlternativeCode;6console.log(actualAlternativeCode('test'));7var strykerParent = require('stryker-parent');8var actualAlternativeCode = strykerParent.actualAlternativeCode;9console.log(actualAlternativeCode('test'));10var strykerParent = require('stryker-parent');11var actualAlternativeCode = strykerParent.actualAlternativeCode;12console.log(actualAlternativeCode('test'));13var strykerParent = require('stryker-parent');14var actualAlternativeCode = strykerParent.actualAlternativeCode;15console.log(actualAlternativeCode('test'));16var strykerParent = require('stryker-parent');17var actualAlternativeCode = strykerParent.actualAlternativeCode;18console.log(actualAlternativeCode('test'));19var strykerParent = require('stryker-parent');20var actualAlternativeCode = strykerParent.actualAlternativeCode;21console.log(actualAlternativeCode('test'));22var strykerParent = require('stryker-parent');23var actualAlternativeCode = strykerParent.actualAlternativeCode;24console.log(actualAlternativeCode('test'));25var strykerParent = require('stryker-parent');26var actualAlternativeCode = strykerParent.actualAlternativeCode;27console.log(actualAlternativeCode('test'));28var strykerParent = require('stryker-parent');

Using AI Code Generation

1const actualAlternativeCode = require('stryker-parent').actualAlternativeCode;2console.log(actualAlternativeCode());3module.exports = {4    actualAlternativeCode: require('stryker-child').actualAlternativeCode5};6module.exports = {7    actualAlternativeCode: () => 'actualAlternativeCode'8};9module.exports = function(config) {10    config.set({11        commandRunner: {12        },13    });14};

Using AI Code Generation

1var parent = require('stryker-parent');2var str = 'actualAlternativeCode';3parent.actualAlternativeCode(str);4module.exports = {5    actualAlternativeCode: function (str) {6        console.log(str);7    }8};9module.exports = {10    actualAlternativeCode: function (str) {11        console.log(str);12    }13};14module.exports = function (config) {15    config.set({16        mochaOptions: {17        }18    });19};

Using AI Code Generation

1const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;2const actualCode = actualAlternativeCode();3console.log("actualCode: " + actualCode);4const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;5const actualCode = actualAlternativeCode();6console.log("actualCode: " + actualCode);7const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;8const actualCode = actualAlternativeCode();9console.log("actualCode: " + actualCode);10const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;11const actualCode = actualAlternativeCode();12console.log("actualCode: " + actualCode);13const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;14const actualCode = actualAlternativeCode();15console.log("actualCode: " + actualCode);16const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;17const actualCode = actualAlternativeCode();18console.log("actualCode: " + actualCode);19const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;20const actualCode = actualAlternativeCode();21console.log("actualCode: " + actualCode);22const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;23const actualCode = actualAlternativeCode();24console.log("actualCode: " + actualCode);25const actualAlternativeCode = require("stryker-parent").actualAlternativeCode;26const actualCode = actualAlternativeCode();27console.log("actualCode: " + actualCode);28const actualAlternativeCode = require("stryker-parent").actualAlternative

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.