Tester deux versions différentes de paquets npm en même temps

Question

Lorsque je crée un paquet npm, il arrive qu'il soit nécessaire de rétablir une ancienne version du paquet de dépendances.

Si la nouvelle version a une nouvelle interface utilisateur, je peux écrire le code selon ce modèle :

import pkg from 'some-pkg';
const isNewVersion = pkg.newVersionApi !== 'undefined';

if (isNewversion) {
  pkg.newVersionApi();
} else {
  pkg.oldVersionApi(); // backward compatible api
}

Et avec ce modèle, lorsque je veux écrire le test, je ne peux tester que l'élément installed version code. Le code de l'autre version ne peut pas être testé.

Par exemple, dans React v15 et v16, React v16 a une nouvelle API Portail . Avant la sortie du portail, la v15 a unstable_renderSubtreeIntoContainer pour réaliser une fonction similaire.

Le code pour React serait donc le suivant :

import ReactDOM from 'react-dom';
const isV16 = ReactDOM.createPortal !== 'undefined';

if (isV16) {
  ReactDOM.createPortal(...);
} else {
  ReactDOM.unstable_renderSubtreeIntoContainer(...);
}

Je voudrais donc savoir s'il existe une méthode pour tester avec different dependency version ?

Actuellement, une méthode à laquelle je pense est d'installer à nouveau l'autre version et de la tester. Mais cela ne peut se faire qu'en local. Elle ne peut pas fonctionner sur ci et ne peut pas compter dans la couverture ensemble.

Je pense que ce n'est pas seulement pour le test de réactivité. Il se peut que ce soit le cas pour les tests node.js. Toute suggestion peut être discutée.

Mise à jour

Cette question est peut-être liée à l'installation two versions dependency dans npm. Mais je sais que l'installation d'une dépendance entre deux versions n'est pas possible.

Answer 1

Voici une solution qui pourrait être envisagée, mais qui n'est pas sûre de fonctionner comme vous l'attendez. Mais vous aurez une direction à suivre pour aller de l'avant.

package.json

{
  "name": "express-demo",
  "version": "0.0.0",
  "private": true,
  "scripts": {
    "start": "node ./bin/www"
  },
  "dependencies": {
    "cookie-parser": "~1.4.3",
    "debug": "~2.6.3",
    "express": "~4.15.2",
    "jade": "~1.11.0",
    "morgan": "~1.8.1",
    "serve-favicon": "~2.4.2",
    "webpack": "^3.8.1",
    "webpack-dev-middleware": "^1.12.0",
    "webpack-hot-middleware": "^2.20.0"
  },
  "customDependecies": {
    "body-parser": [
      "",
      "1.18.1",
      "1.18.0"
    ]
  }
}

Note ci-dessus package.json j'ai ajouté une nouvelle clé customDependecies que j'utiliserai pour installer plusieurs dépendances. Ici, j'utilise body-parser pour la démonstration. Ensuite, vous avez besoin d'un fichier qui peut se lire comme suit key et installez les composants.

install-deps.js

const {spawnSync} = require('child_process');
const fs = require('fs');

const customDependencies = require('./package.json').customDependecies;

spawnSync('mkdir', ['./node_modules/.tmp']);

for (var dependency in customDependencies) {
  customDependencies[dependency].forEach((version) => {
    console.log(`Installing ${dependency}@${version}`);
    if (version) {
      spawnSync('npm', ['install', `${dependency}@${version}`]);
      spawnSync('mv', [`./node_modules/${dependency}`, `./node_modules/.tmp/${dependency}@${version}`]);
    } else {
      spawnSync('npm', ['install', `${dependency}`]);
      spawnSync('mv', [`./node_modules/${dependency}`, `./node_modules/.tmp/${dependency}`]);
    }
  });

  customDependencies[dependency].forEach((version) => {
    console.log(`Moving ${dependency}@${version}`);
    if (version) {
      spawnSync('mv', [`./node_modules/.tmp/${dependency}@${version}`, `./node_modules/${dependency}@${version}`]);
    } else {
      spawnSync('mv', [`./node_modules/.tmp/${dependency}`, `./node_modules/${dependency}`]);
    }
  });
}
spawnSync('rm', ['-rf', './node_modules/.tmp']);
console.log(`Installing Deps finished.`);

Ici, j'installe les modules de développement un par un dans tmp et une fois installés, je les déplace dans le dossier ./node_modules dossier.

Une fois que tout est installé, vous pouvez vérifier les versions comme ci-dessous

index.js

var bodyParser = require('body-parser/package.json');
var bodyParser1181 = require('body-parser@1.18.1/package.json');
var bodyParser1182 = require('body-parser@1.18.0/package.json');

console.log(bodyParser.version);
console.log(bodyParser1181.version);
console.log(bodyParser1182.version);

J'espère que cela vous sera utile.

Answer 2

Créer 3 projets distincts (dossiers avec package.json) et un dossier partagé :

1. Un dossier partagé contenant le module de test ( my-test ). Exporter une fonction pour exécuter le test ;
2. Un projet client qui importe my-test et la dépendance v1. Exporter une fonction qui appelle la fonction de test dans my-test .
3. Un projet client qui importe my-test et dépendance v2. Exporter une fonction qui appelle la fonction de test dans my-test .
4. Un projet maître qui importe les deux projets clients. Exécutez chaque fonction exportée.

Answer 3

Vous devrez les gérer séparément. Créez un dossier de projet distinct pour chaque version de dépendance. Ex. React10, React11, React12. Chacun aura son propre dossier package.json , spécifié pour la version correcte. Lorsque vous exécutez le programme integration et/ou versioned vous exécuterez vos tests unitaires standard pour chaque version, mais il peut également être judicieux d'ajouter à ce dossier les tests unitaires spécifiques à chaque version.

Création d'un make vous faciliterait la vie lors de l'exécution de votre suite de tests complète. Si vous faites cela, vous pouvez facilement l'intégrer dans CI.