Description: replace ava by jest
Author: Yadd <yadd@debian.org>
Forwarded: not-needed
Last-Update: 2022-10-29

--- /dev/null
+++ b/packages/inject/test/__snapshots__/test.js.snap
@@ -0,0 +1,146 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`escapes apostrophes in module name 1`] = `
+"import { default as $ } from 'd\\'oh';
+
+$(() => {
+  console.log('ready');
+});
+"
+`;
+
+exports[`escapes backslashes in module name 1`] = `
+"import { default as $ } from 'slash\\\\back';
+
+$(() => {
+  console.log('ready');
+});
+"
+`;
+
+exports[`generates * imports 1`] = `
+"import * as foo from 'foo';
+
+console.log(foo.bar);
+console.log(foo.baz);
+"
+`;
+
+exports[`handles redundant keys 1`] = `
+"import { default as $inject_Buffer_isBuffer } from 'is-buffer';
+
+$inject_Buffer_isBuffer('foo');
+"
+`;
+
+exports[`handles shadowed variables 1`] = `
+"function launch($) {
+  $(() => {
+    console.log('ready');
+  });
+}
+
+launch((fn) => fn());
+"
+`;
+
+exports[`handles shorthand properties (as assignment) 1`] = `
+"const { Promise = "fallback" } = foo;
+console.log(Promise);
+
+"
+`;
+
+exports[`handles shorthand properties 1`] = `
+"import { Promise as Promise } from 'es6-promise';
+
+const polyfills = { Promise };
+polyfills.Promise.resolve().then(() => 'it works');
+"
+`;
+
+exports[`handles shorthand properties in function (as fallback value) 1`] = `
+"import { Promise as Promise } from 'es6-promise';
+
+function foo({bar = Promise}) {
+  console.log(bar);
+}
+foo();
+
+"
+`;
+
+exports[`handles shorthand properties in function 1`] = `
+"function foo({Promise}) {
+  console.log(Promise);
+}
+foo();
+
+"
+`;
+
+exports[`ignores check isReference is false 1`] = `
+"import { bar as foo } from 'path';
+
+console.log({ bar: foo });
+class Foo {
+  bar() {
+    console.log(this);
+  }
+}
+export { Foo };
+export { foo as bar };
+"
+`;
+
+exports[`ignores existing imports 1`] = `
+"import $ from 'jquery';
+
+$(() => {
+  console.log('ready');
+});
+"
+`;
+
+exports[`inserts a default import statement 1`] = `
+"import { default as $ } from 'jquery';
+
+$(() => {
+  console.log('ready');
+});
+"
+`;
+
+exports[`inserts a named import statement 1`] = `
+"import { Promise as Promise } from 'es6-promise';
+
+Promise.all([thisThing, thatThing]).then(() => someOtherThing);
+"
+`;
+
+exports[`overwrites keypaths 1`] = `
+"import { default as $inject_Object_assign } from 'fixtures/keypaths/polyfills/object-assign.js';
+
+const original = { foo: 'bar' };
+const clone = $inject_Object_assign({}, original);
+
+export default clone;
+"
+`;
+
+exports[`transpiles non-JS files but handles failures to parse 1`] = `
+"import './styles.css';
+import foo from './foo.es6';
+
+assert.equal(foo, path.join('..', 'baz'));
+"
+`;
+
+exports[`uses the modules property 1`] = `
+"import { default as $ } from 'jquery';
+
+$(() => {
+  console.log('ready');
+});
+"
+`;
--- a/packages/inject/test/test.js
+++ b/packages/inject/test/test.js
@@ -3,11 +3,10 @@
 const os = require('os');
 
 const acorn = require('acorn');
-const test = require('ava');
 
 const inject = require('..');
 
-const compare = (t, fixture, options) => {
+const compare = (fixture, options) => {
   const filename = path.resolve(`test/fixtures/${fixture}/input.js`);
   const input = fs.readFileSync(filename, 'utf-8');
   const output = inject(options).transform.call(
@@ -22,81 +21,81 @@
     filename
   );
 
-  t.snapshot(output ? output.code : input);
+  expect(output ? output.code : input).toMatchSnapshot();
 };
 
-test('inserts a default import statement', (t) => {
-  compare(t, 'basic', { $: 'jquery' });
+test('inserts a default import statement', () => {
+  compare('basic', { $: 'jquery' });
 });
 
-test('uses the modules property', (t) => {
-  compare(t, 'basic', {
+test('uses the modules property', () => {
+  compare('basic', {
     modules: { $: 'jquery' }
   });
 });
 
-test('escapes apostrophes in module name', (t) => {
-  compare(t, 'basic', { $: "d'oh" });
+test('escapes apostrophes in module name', () => {
+  compare('basic', { $: "d'oh" });
 });
 
 if (os.platform() === 'win32') {
   // backslash is path separator on Windows,
   // so it cannot appear within filename
 } else {
-  test('escapes backslashes in module name', (t) => {
-    compare(t, 'basic', { $: 'slash\\back' });
+  test('escapes backslashes in module name', () => {
+    compare('basic', { $: 'slash\\back' });
   });
 }
 
-test('inserts a named import statement', (t) => {
-  compare(t, 'named', { Promise: ['es6-promise', 'Promise'] });
+test('inserts a named import statement', () => {
+  compare('named', { Promise: ['es6-promise', 'Promise'] });
 });
 
-test('overwrites keypaths', (t) => {
-  compare(t, 'keypaths', {
+test('overwrites keypaths', () => {
+  compare('keypaths', {
     'Object.assign': 'fixtures/keypaths/polyfills/object-assign.js'
   });
 });
 
-test('ignores existing imports', (t) => {
-  compare(t, 'existing', { $: 'jquery' });
+test('ignores existing imports', () => {
+  compare('existing', { $: 'jquery' });
 });
 
-test('handles shadowed variables', (t) => {
-  compare(t, 'shadowing', { $: 'jquery' });
+test('handles shadowed variables', () => {
+  compare('shadowing', { $: 'jquery' });
 });
 
-test('handles shorthand properties', (t) => {
-  compare(t, 'shorthand', { Promise: ['es6-promise', 'Promise'] });
+test('handles shorthand properties', () => {
+  compare('shorthand', { Promise: ['es6-promise', 'Promise'] });
 });
 
-test('handles shorthand properties (as assignment)', (t) => {
-  compare(t, 'shorthand-assignment', { Promise: ['es6-promise', 'Promise'] });
+test('handles shorthand properties (as assignment)', () => {
+  compare('shorthand-assignment', { Promise: ['es6-promise', 'Promise'] });
 });
 
-test('handles shorthand properties in function', (t) => {
-  compare(t, 'shorthand-func', { Promise: ['es6-promise', 'Promise'] });
+test('handles shorthand properties in function', () => {
+  compare('shorthand-func', { Promise: ['es6-promise', 'Promise'] });
 });
 
-test('handles shorthand properties in function (as fallback value)', (t) => {
-  compare(t, 'shorthand-func-fallback', { Promise: ['es6-promise', 'Promise'] });
+test('handles shorthand properties in function (as fallback value)', () => {
+  compare('shorthand-func-fallback', { Promise: ['es6-promise', 'Promise'] });
 });
 
-test('handles redundant keys', (t) => {
-  compare(t, 'redundant-keys', {
+test('handles redundant keys', () => {
+  compare('redundant-keys', {
     Buffer: 'Buffer',
     'Buffer.isBuffer': 'is-buffer'
   });
 });
 
-test('generates * imports', (t) => {
-  compare(t, 'import-namespace', { foo: ['foo', '*'] });
+test('generates * imports', () => {
+  compare('import-namespace', { foo: ['foo', '*'] });
 });
 
-test('transpiles non-JS files but handles failures to parse', (t) => {
-  compare(t, 'non-js', { relative: ['path', 'relative'] });
+test('transpiles non-JS files but handles failures to parse', () => {
+  compare('non-js', { relative: ['path', 'relative'] });
 });
 
-test('ignores check isReference is false', (t) => {
-  compare(t, 'is-reference', { bar: 'path' });
+test('ignores check isReference is false', () => {
+  compare('is-reference', { bar: 'path' });
 });