added tests

Author: darangi

script/lib/update-dependency/fetch-outdated-dependencies.js

@@ -0,0 +1,80 @@
+const fetch = require('node-fetch');
+const npmCheck = require('npm-check');
+
+// this may be updated to use github releases instead
+const apm = async function({ dependencies, packageDependencies }) {
+  try {
+    console.log('Checking apm registry...');
+    const coreDependencies = Object.keys(dependencies).filter(dependency => {
+      // all core packages point to a remote url
+      return dependencies[dependency].match(new RegExp('^https?://'));
+    });
+
+    const promises = coreDependencies.map(async dependency => {
+      return fetch(`https://atom.io/api/packages/${dependency}`)
+        .then(res => res.json())
+        .then(res => res)
+        .catch(ex => console.log(ex.message));
+    });
+
+    const packages = await Promise.all(promises);
+    const outdatedPackages = [];
+    packages.map(dependency => {
+      if (dependency.hasOwnProperty('name')) {
+        const latestVersion = dependency.releases.latest;
+        const installed = packageDependencies[dependency.name];
+        if (latestVersion > installed) {
+          outdatedPackages.push({
+            moduleName: dependency.name,
+            latest: dependency.releases.latest,
+            isCorePackage: true,
+            installed
+          });
+        }
+      }
+    });
+
+    console.log(`${outdatedPackages.length} outdated package(s) found`);
+
+    return outdatedPackages;
+  } catch (ex) {
+    console.error(`An error occured: ${ex.message}`);
+  }
+};
+
+const npm = async function(cwd) {
+  try {
+    console.log('Checking npm registry...');
+
+    const currentState = await npmCheck({
+      cwd,
+      ignoreDev: true,
+      skipUnused: true
+    });
+    const outdatedPackages = currentState
+      .get('packages')
+      .filter(p => {
+        if (p.packageJson && p.latest && p.installed) {
+          return p.latest > p.installed;
+        }
+      })
+      .map(({ packageJson, installed, moduleName, latest }) => ({
+        packageJson,
+        installed,
+        moduleName,
+        latest,
+        isCorePackage: false
+      }));
+
+    console.log(`${outdatedPackages.length} outdated package(s) found`);
+
+    return outdatedPackages;
+  } catch (ex) {
+    console.error(`An error occured: ${ex.message}`);
+  }
+};
+
+module.exports = {
+  apm,
+  npm
+};

script/lib/update-dependency/git.js

@@ -0,0 +1,67 @@
+const git = (git, repositoryRootPath) => {
+  const path = require('path');
+  const packageJsonFilePath = path.join(repositoryRootPath, 'package.json');
+  const packageLockFilePath = path.join(
+    repositoryRootPath,
+    'package-lock.json'
+  );
+  try {
+    git.getRemotes((err, remotes) => {
+      if (!err && !remotes.map(({ name }) => name).includes('ATOM')) {
+        git.addRemote(
+          'ATOM',
+          `https://atom:${process.env.AUTH_TOKEN}@github.com/atom/atom.git/`
+        );
+      }
+    });
+  } catch (ex) {
+    console.log(ex.message);
+  }
+  return {
+    switchToMaster: async function() {
+      const { current } = await git.branch();
+      if (current !== 'master') {
+        await git.checkout('master');
+      }
+    },
+    makeBranch: async function(dependency) {
+      const newBranch = `${dependency.moduleName}-${dependency.latest}`;
+      const { branches } = await git.branch();
+      const { files } = await git.status();
+      if (files.length > 0) {
+        await git.reset('hard');
+      }
+      const found = Object.keys(branches).find(
+        branch => branch.indexOf(newBranch) > -1
+      );
+      found
+        ? await git.checkout(found)
+        : await git.checkoutLocalBranch(newBranch);
+      return { found, newBranch };
+    },
+    createCommit: async function({ moduleName, latest }) {
+      try {
+        const commitMessage = `:arrow_up: ${moduleName}@${latest}`;
+        await git.add([packageJsonFilePath, packageLockFilePath]);
+        await git.commit(commitMessage);
+      } catch (ex) {
+        throw Error(ex.message);
+      }
+    },
+    publishBranch: async function(branch) {
+      try {
+        await git.push('ATOM', branch);
+      } catch (ex) {
+        throw Error(ex.message);
+      }
+    },
+    deleteBranch: async function(branch) {
+      try {
+        await git.deleteLocalBranch(branch, true);
+      } catch (ex) {
+        throw Error(ex.message);
+      }
+    }
+  };
+};
+module.exports = git;

script/lib/update-dependency/main.js

@@ -0,0 +1,97 @@
+/* eslint-disable camelcase */
+const simpleGit = require('simple-git');
+const path = require('path');
+
+const { repositoryRootPath } = require('../../config');
+const packageJSON = require(path.join(repositoryRootPath, 'package.json'));
+const git = simpleGit(repositoryRootPath);
+const { createPR, findPR, addLabel } = require('./pull-request');
+const runApmInstall = require('../run-apm-install');
+const {
+  makeBranch,
+  createCommit,
+  switchToMaster,
+  publishBranch,
+  deleteBranch
+} = require('./git')(git, repositoryRootPath);
+const { updatePackageJson, sleep } = require('./util')(repositoryRootPath);
+const fetchOutdatedDependencies = require('./fetch-outdated-dependencies');
+
+module.exports = async function() {
+  try {
+    // ensure we are on master
+    await switchToMaster();
+    const failedBumps = [];
+    const successfullBumps = [];
+    const outdateDependencies = [
+      ...(await fetchOutdatedDependencies.npm(repositoryRootPath)),
+      ...(await fetchOutdatedDependencies.apm(packageJSON))
+    ];
+    const totalDependencies = outdateDependencies.length;
+    const pendingPRs = [];
+    for (const dependency of outdateDependencies) {
+      const { found, newBranch } = await makeBranch(dependency);
+      if (found) {
+        console.log(`Branch was found ${found}`);
+        console.log('checking if a PR already exists');
+        const {
+          data: { total_count }
+        } = await findPR(dependency, newBranch);
+        if (total_count > 0) {
+          console.log(`pull request found!`);
+        } else {
+          console.log(`pull request not found!`);
+          const pr = { dependency, branch: newBranch, branchIsRemote: false };
+          // confirm if branch found is a local branch
+          if (found.indexOf('remotes') === -1) {
+            await publishBranch(found);
+          } else {
+            pr.branchIsRemote = true;
+          }
+          pendingPRs.push(pr);
+        }
+      } else {
+        await updatePackageJson(dependency);
+        runApmInstall(repositoryRootPath, false);
+        await createCommit(dependency);
+        await publishBranch(newBranch);
+        pendingPRs.push({
+          dependency,
+          branch: newBranch,
+          branchIsRemote: false
+        });
+      }
+
+      await switchToMaster();
+    }
+    // create PRs here
+    for (const { dependency, branch, branchIsRemote } of pendingPRs) {
+      const { status, data = {} } = await createPR(dependency, branch);
+      if (status === 201) {
+        successfullBumps.push(dependency);
+        await addLabel(data.number);
+      } else {
+        failedBumps.push(dependency);
+      }
+
+      if (!branchIsRemote) {
+        await deleteBranch(branch);
+      }
+      // https://developer.github.com/v3/guides/best-practices-for-integrators/#dealing-with-abuse-rate-limits
+      await sleep(2000);
+    }
+    console.table([
+      {
+        totalDependencies,
+        totalSuccessfullBumps: successfullBumps.length,
+        totalFailedBumps: failedBumps.length
+      }
+    ]);
+    console.log('Successfull bumps');
+    console.table(successfullBumps);
+    console.log('Failed bumps');
+    console.table(failedBumps);
+  } catch (ex) {
+    console.log(ex.message);
+  }
+};

script/lib/update-dependency/spec/fetch-outdated-dependencies-spec.js

@@ -0,0 +1,27 @@
+const path = require('path');
+const fetchOutdatedDependencies = require('../fetch-outdated-dependencies');
+const { nativeDependencies } = require('./helpers');
+const repositoryRootPath = path.resolve('.', 'fixtures', 'dummy');
+const packageJSON = require(path.join(repositoryRootPath, 'package.json'));
+
+describe('Fetch outdated dependencies', function() {
+  it('should fetch outdated native dependencies', async () => {
+    spyOn(fetchOutdatedDependencies, 'npm').andReturn(
+      Promise.resolve(nativeDependencies)
+    );
+
+    expect(await fetchOutdatedDependencies.npm(repositoryRootPath)).toEqual(
+      nativeDependencies
+    );
+  });
+
+  it('should fetch outdated core dependencies', async () => {
+    spyOn(fetchOutdatedDependencies, 'apm').andReturn(
+      Promise.resolve(nativeDependencies)
+    );
+
+    expect(await fetchOutdatedDependencies.apm(packageJSON)).toEqual(
+      nativeDependencies
+    );
+  });
+});

script/lib/update-dependency/spec/fixtures/dummy

@@ -0,0 +1 @@
+Subproject commit 526c50836158b43d38cbaf11ad305fa8a6f43d1f

script/lib/update-dependency/spec/fixtures/latest-package.json

@@ -0,0 +1,28 @@
+{
+    "name": "test",
+    "version": "1.0.0",
+    "description": "just test",
+    "main": "index.js",
+    "dependencies": {
+      "spell-check": "https://www.atom.io/api/packages/spell-check/versions/0.79.1/tarball",
+      "status-bar": "https://www.atom.io/api/packages/status-bar/versions/2.8.17/tarball",
+      "styleguide": "https://www.atom.io/api/packages/styleguide/versions/1.49.12/tarball",
+      "symbols-view": "https://www.atom.io/api/packages/symbols-view/versions/0.118.5/tarball",
+      "@atom/watcher": "1.3.1",
+      "clear-cut": "^2.0.3",
+      "dedent": "^1.0.0",
+      "devtron": "1.2.6"
+    },
+    "packageDependencies": {
+      "spell-check": "0.79.1",
+      "status-bar": "2.8.17",
+      "styleguide": "1.49.12",
+      "symbols-view": "0.118.5"
+    },
+    "scripts": {
+      "test": "echo \"Error: no test specified\" && exit 1"
+    },
+    "author": "darangi",
+    "license": "ISC"
+  }
+