@toptal/davinci-monorepo 6.7.2-alpha-fix-package-version-test.0 → 6.7.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @toptal/davinci-monorepo
 
+## 6.7.2
+
+### Patch Changes
+
+- Updated dependencies [[`b12d1d19`](https://github.com/toptal/davinci/commit/b12d1d19af02104b9076a53b6e516198e6cda141)]:
+  - @toptal/davinci-cli-shared@1.8.1
+
 ## 6.7.1
 
 ### Patch Changes

package/dist-package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@toptal/davinci-monorepo",
+  "version": "6.7.2",
+  "description": "Monorepo utility tools",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "lint"
+  ],
+  "author": "Toptal",
+  "homepage": "https://github.com/toptal/davinci/tree/master/packages/monorepo#readme",
+  "license": "ISC",
+  "main": "src/index.js",
+  "bin": {
+    "davinci-monorepo": "bin/davinci-monorepo.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/toptal/davinci.git"
+  },
+  "scripts": {
+    "build:package": "../../bin/build-package.js",
+    "prepublishOnly": "../../bin/prepublish.js",
+    "test": "echo \"Error: run tests from root\" && exit 1"
+  },
+  "bugs": {
+    "url": "https://github.com/toptal/davinci/issues"
+  },
+  "dependencies": {
+    "@toptal/davinci-cli-shared": "1.8.1",
+    "glob": "^8.0.3",
+    "execa": "^5.1.1",
+    "chalk": "^4.1.2",
+    "@oclif/core": "^1.16.1",
+    "rambda": "^7.2.1",
+    "dependency-cruiser": "^11.15.0",
+    "ora": "^5.4.1"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toptal/davinci-monorepo",
-  "version": "6.7.2-alpha-fix-package-version-test.0+e47569ec",
+  "version": "6.7.2",
   "description": "Monorepo utility tools",
   "publishConfig": {
     "access": "public"
@@ -28,14 +28,13 @@
     "url": "https://github.com/toptal/davinci/issues"
   },
   "dependencies": {
-    "@oclif/core": "^1.16.1",
-    "@toptal/davinci-cli-shared": "1.8.1-alpha-fix-package-version-test.29+e47569ec",
+    "@toptal/davinci-cli-shared": "1.8.1",
+    "glob": "^8.0.3",
+    "execa": "^5.1.1",
     "chalk": "^4.1.2",
+    "@oclif/core": "^1.16.1",
+    "rambda": "^7.2.1",
     "dependency-cruiser": "^11.15.0",
-    "execa": "^5.1.1",
-    "glob": "^8.0.3",
-    "ora": "^5.4.1",
-    "rambda": "^7.2.1"
-  },
-  "gitHead": "e47569ec6bdd4504eb81d13c6bebfa3013b32840"
+    "ora": "^5.4.1"
+  }
 }

package/src/services/metrics/package-instability.test.js

@@ -0,0 +1,228 @@
+/* eslint-disable max-lines */
+const calculateRelativeResponsibility = jest.fn()
+const calculateRelations = jest.fn()
+
+jest.mock('./relative-responsibility', () => ({
+  ...jest.requireActual('./relative-responsibility'),
+  calculate: calculateRelativeResponsibility,
+}))
+
+jest.mock('./package-relations', () => ({
+  ...jest.requireActual('./package-relations'),
+  calculate: calculateRelations,
+}))
+
+const { info, INST, calculate } = require('./package-instability')
+const { RELATIVE_RESPONSIBILITY } = require('./relative-responsibility')
+const { PAR, PER } = require('./package-relations')
+
+describe('metrics: package instability', () => {
+  beforeEach(() => {
+    calculateRelativeResponsibility.mockReturnValue({})
+    calculateRelations.mockReturnValue({})
+  })
+
+  it('returns metric info', () => {
+    expect(info).toEqual({
+      [INST]: {
+        name: 'Instability',
+      },
+    })
+  })
+
+  describe('when Relative Responsibility of package2, package3 equals 1', () => {
+    describe('when PAR equals 1, PER equals 2', () => {
+      it('returns zero instability', () => {
+        const result = calculate[2]({
+          packagesInfo: {
+            package1: {
+              dependencies: ['package2', 'package3'],
+              [PAR]: 1,
+              [PER]: 2,
+            },
+            package2: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 1,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+            package3: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 1,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+          },
+        })
+
+        expect(result).toEqual({
+          package1: {
+            instability: 0,
+          },
+          package2: {
+            instability: 0,
+          },
+          package3: {
+            instability: 0,
+          },
+        })
+      })
+    })
+  })
+
+  describe('when Relative Responsibility of package2 equals 1, package2 equals 0.2', () => {
+    describe('when PAR equals 1, PER equals 2', () => {
+      it('returns non zero instability', () => {
+        const result = calculate[2]({
+          packagesInfo: {
+            package1: {
+              dependencies: ['package2', 'package3'],
+              [PAR]: 1,
+              [PER]: 2,
+            },
+            package2: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 1,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+            package3: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0.2,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+          },
+        })
+
+        expect(result).toEqual({
+          package1: {
+            instability: 0.26667,
+          },
+          package2: {
+            instability: 0,
+          },
+          package3: {
+            instability: 0,
+          },
+        })
+      })
+    })
+  })
+
+  describe('when Relative Responsibility of package2, package3 equals 0', () => {
+    describe('when PAR equals 0, PER equals 1', () => {
+      it('returns instability = 1', () => {
+        const result = calculate[2]({
+          packagesInfo: {
+            package1: {
+              dependencies: ['package2'],
+              [PAR]: 0,
+              [PER]: 1,
+            },
+            package2: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+            package3: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+          },
+        })
+
+        expect(result).toEqual({
+          package1: {
+            instability: 1,
+          },
+          package2: {
+            instability: 0,
+          },
+          package3: {
+            instability: 0,
+          },
+        })
+      })
+    })
+
+    describe('when PAR equals 1, PER equals 1', () => {
+      it('returns non zero instability', () => {
+        const result = calculate[2]({
+          packagesInfo: {
+            package1: {
+              dependencies: ['package2'],
+              [PAR]: 1,
+              [PER]: 1,
+            },
+            package2: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+            package3: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+          },
+        })
+
+        expect(result).toEqual({
+          package1: {
+            instability: 0.5,
+          },
+          package2: {
+            instability: 0,
+          },
+          package3: {
+            instability: 0,
+          },
+        })
+      })
+    })
+
+    describe('when PAR equals 1, PER equals 2', () => {
+      it('returns non zero instability', () => {
+        const result = calculate[2]({
+          packagesInfo: {
+            package1: {
+              dependencies: ['package2', 'package3'],
+              [PAR]: 1,
+              [PER]: 2,
+            },
+            package2: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+            package3: {
+              dependencies: [],
+              [RELATIVE_RESPONSIBILITY]: 0,
+              [PAR]: 1,
+              [PER]: 1,
+            },
+          },
+        })
+
+        expect(result).toEqual({
+          package1: {
+            instability: 0.66667,
+          },
+          package2: {
+            instability: 0,
+          },
+          package3: {
+            instability: 0,
+          },
+        })
+      })
+    })
+  })
+})

package/src/services/metrics/package-relations.test.js

@@ -0,0 +1,84 @@
+const { calculate, info, PAR, PER } = require('./package-relations')
+
+const packagesInfo = {
+  package1: {
+    name: 'package1',
+    dependents: ['package2', 'package3'],
+    dependencies: [],
+  },
+  package2: {
+    name: 'package2',
+    dependents: ['package3'],
+    dependencies: ['package1'],
+  },
+  package3: {
+    name: 'package3',
+    dependents: [],
+    dependencies: ['package1', 'package2'],
+  },
+}
+
+describe('metrics: package relations', () => {
+  it('returns metric info', () => {
+    expect(info).toEqual({
+      [PAR]: {
+        name: 'Package Afferent Relations',
+      },
+      [PER]: {
+        name: 'Package Efferent Relations',
+      },
+    })
+  })
+
+  describe('when there are 3 dependent packages', () => {
+    it('calculates and returns relations metrics', () => {
+      const result = calculate({ packagesInfo })
+
+      expect(result).toEqual({
+        package1: {
+          [PAR]: 2,
+          [PER]: 0,
+        },
+        package2: {
+          [PAR]: 1,
+          [PER]: 1,
+        },
+        package3: {
+          [PAR]: 0,
+          [PER]: 2,
+        },
+      })
+    })
+  })
+
+  describe('when there is 1 dependent package', () => {
+    it('calculates and returns relations metrics', () => {
+      const result = calculate({
+        packagesInfo: {
+          package1: {
+            name: 'package1',
+            dependents: [],
+            dependencies: [],
+          },
+        },
+      })
+
+      expect(result).toEqual({
+        package1: {
+          [PAR]: 0,
+          [PER]: 0,
+        },
+      })
+    })
+  })
+
+  describe('when there are NO packages', () => {
+    it('calculates and returns empty object', () => {
+      const result = calculate({
+        packagesInfo: {},
+      })
+
+      expect(result).toEqual({})
+    })
+  })
+})

package/src/services/metrics/relative-responsibility.test.js

@@ -0,0 +1,60 @@
+const calculateRelativeResponsibility = jest.fn()
+
+jest.mock('./responsibility', () => ({
+  ...jest.requireActual('./responsibility'),
+  calculate: calculateRelativeResponsibility,
+}))
+
+const {
+  calculate,
+  info,
+  RELATIVE_RESPONSIBILITY,
+} = require('./relative-responsibility')
+const { RESPONSIBILITY } = require('./responsibility')
+
+describe('metrics: package normalized responsibility', () => {
+  beforeEach(() => {
+    calculateRelativeResponsibility.mockReturnValue({})
+  })
+
+  it('returns metric info', () => {
+    expect(info).toEqual({
+      [RELATIVE_RESPONSIBILITY]: {
+        name: 'Relative Responsibility',
+      },
+    })
+  })
+
+  describe('when package1 has the highest "RESPONSIBILITY"', () => {
+    it('returns 1 RELATIVE_RESPONSIBILITY metric for the package1', () => {
+      const response = calculate[1]({
+        packagesInfo: {
+          package1: {
+            name: 'package1',
+            [RESPONSIBILITY]: 3,
+          },
+          package2: {
+            name: 'package2',
+            [RESPONSIBILITY]: 2,
+          },
+          package3: {
+            name: 'package3',
+            [RESPONSIBILITY]: 1,
+          },
+        },
+      })
+
+      expect(response).toEqual({
+        package1: {
+          [RELATIVE_RESPONSIBILITY]: 1,
+        },
+        package2: {
+          [RELATIVE_RESPONSIBILITY]: 0.6666666666666666,
+        },
+        package3: {
+          [RELATIVE_RESPONSIBILITY]: 0.3333333333333333,
+        },
+      })
+    })
+  })
+})

package/src/services/metrics/responsibility.test.js

@@ -0,0 +1,108 @@
+const { RESPONSIBILITY, calculate, info } = require('./responsibility')
+
+describe('metrics: package relative responsibility', () => {
+  it('returns metric info', () => {
+    expect(info).toEqual({
+      [RESPONSIBILITY]: {
+        name: 'Responsibility',
+      },
+    })
+  })
+
+  it('returns a "RESPONSIBILITY" metrics for each package', () => {
+    const result = calculate({
+      packagesInfo: {
+        package1: {
+          dependents: ['package2', 'package3'],
+          dependencies: [],
+        },
+        package2: {
+          dependents: ['package3'],
+          dependencies: ['package1'],
+        },
+        package3: {
+          dependents: [],
+          dependencies: ['package1', 'package2'],
+        },
+      },
+    })
+
+    expect(result).toEqual({
+      package1: {
+        [RESPONSIBILITY]: 0.75,
+      },
+      package2: {
+        [RESPONSIBILITY]: 0.25,
+      },
+      package3: {
+        [RESPONSIBILITY]: 0,
+      },
+    })
+  })
+
+  describe('when all packages have dependencies', () => {
+    it('returns a "RESPONSIBILITY" metrics for each package', () => {
+      const result = calculate({
+        packagesInfo: {
+          package1: {
+            dependents: ['package2', 'package3'],
+            dependencies: ['package3'],
+          },
+          package2: {
+            dependents: ['package3'],
+            dependencies: ['package1'],
+          },
+          package3: {
+            dependents: [],
+            dependencies: ['package1', 'package2'],
+          },
+        },
+      })
+
+      expect(result).toEqual({
+        package1: {
+          [RESPONSIBILITY]: 0.5,
+        },
+        package2: {
+          [RESPONSIBILITY]: 0.16666666666666666,
+        },
+        package3: {
+          [RESPONSIBILITY]: 0,
+        },
+      })
+    })
+  })
+
+  describe('when packages are isolated', () => {
+    it('returns a "RESPONSIBILITY" metrics for each package', () => {
+      const result = calculate({
+        packagesInfo: {
+          package1: {
+            dependents: [],
+            dependencies: [],
+          },
+          package2: {
+            dependents: [],
+            dependencies: [],
+          },
+          package3: {
+            dependents: [],
+            dependencies: [],
+          },
+        },
+      })
+
+      expect(result).toEqual({
+        package1: {
+          [RESPONSIBILITY]: NaN,
+        },
+        package2: {
+          [RESPONSIBILITY]: NaN,
+        },
+        package3: {
+          [RESPONSIBILITY]: NaN,
+        },
+      })
+    })
+  })
+})

package/src/services/renderers/csv.test.js

@@ -0,0 +1,29 @@
+const csv = require('./csv')
+
+const metricInfo = {
+  metric1: { name: 'Metric 1' },
+  metric2: { name: 'Metric 2' },
+}
+
+const packagesInfo = {
+  package1: {
+    name: 'Package 1',
+    metric1: 0,
+    metric2: 2.0,
+  },
+  package2: {
+    name: 'Package 2',
+    metric1: 1,
+    metric2: 3.0,
+  },
+}
+
+describe('csv renderer', () => {
+  it('returns a csv string', () => {
+    const result = csv(metricInfo, packagesInfo)
+
+    expect(result).toBe(
+      'Package Name,Metric 1,Metric 2\n' + 'package1,0,2\n' + 'package2,1,3'
+    )
+  })
+})

package/src/services/renderers/raw.test.js

@@ -0,0 +1,69 @@
+const buildTable = jest.fn()
+
+jest.mock('@oclif/core', () => ({
+  CliUx: {
+    ux: {
+      table: buildTable,
+    },
+  },
+}))
+
+const raw = require('./raw')
+
+const metricInfo = {
+  metric1: { name: 'Metric 1' },
+  metric2: { name: 'Metric 2' },
+}
+
+const packagesInfo = {
+  package1: {
+    name: 'Package 1',
+    metric1: 0,
+    metric2: 2.0,
+  },
+  package2: {
+    name: 'Package 2',
+    metric1: 1,
+    metric2: 3.0,
+  },
+}
+
+describe('raw renderer', () => {
+  beforeEach(() => {
+    buildTable.mockImplementation((value, columns, { printLine }) =>
+      printLine(`buildTable(${JSON.stringify(value)})`)
+    )
+  })
+
+  afterEach(() => {
+    buildTable.mockReset()
+  })
+
+  it('returns a raw string', () => {
+    const result = raw(metricInfo, packagesInfo)
+
+    expect(result).toBe(
+      'buildTable([{"name":"Package 1","metric1":0,"metric2":2},{"name":"Package 2","metric1":1,"metric2":3}])\n'
+    )
+  })
+
+  it('calls print.prettifyMatrix with proper params', () => {
+    raw(metricInfo, packagesInfo)
+
+    expect(buildTable).toHaveBeenCalledTimes(1)
+    expect(buildTable).toHaveBeenCalledWith(
+      [
+        { name: 'Package 1', metric1: 0, metric2: 2 },
+        { name: 'Package 2', metric1: 1, metric2: 3 },
+      ],
+      {
+        metric1: { header: 'Metric 1' },
+        metric2: { header: 'Metric 2' },
+        name: { header: 'Package Name' },
+      },
+      {
+        printLine: expect.any(Function),
+      }
+    )
+  })
+})

package/src/utils/check-if-monorepo.test.js

@@ -0,0 +1,28 @@
+jest.mock('execa', () => ({
+  ...jest.requireActual('execa'),
+  sync: jest.fn(() => true),
+}))
+
+const execa = require('execa')
+
+const checkIfMonorepo = require('./check-if-monorepo')
+
+execa.sync = jest.fn(() => true)
+
+describe('checkIfMonorepo', () => {
+  it('returns true if the project is monorepo', () => {
+    const isMonorepo = checkIfMonorepo()
+
+    expect(isMonorepo).toBe(true)
+  })
+
+  it('returns false if the project is not a monorepo', () => {
+    execa.sync.mockImplementation(() => {
+      throw new Error('Cannot execute lerna')
+    })
+
+    const isMonorepo = checkIfMonorepo()
+
+    expect(isMonorepo).toBe(false)
+  })
+})

package/src/utils/get-circularity-error-message.test.js

@@ -0,0 +1,13 @@
+const getCircularityErrorMessage = require('./get-circularity-error-message')
+
+describe('getCircularityErrorMessage', () => {
+  it('returns one cycle path', () => {
+    expect(
+      getCircularityErrorMessage([
+        ['lib-1', 'lib-3', 'lib-4', 'lib-5', 'lib-1'],
+      ])
+    ).toBe(
+      'Circular dependencies found:\n1. lib-1 -> lib-3 -> lib-4 -> lib-5 -> lib-1\n'
+    )
+  })
+})

package/src/utils/get-graph-cycle-paths.test.js

@@ -0,0 +1,53 @@
+const getGraphCyclePaths = require('./get-graph-cycle-paths')
+
+const NO_CYCLES_GRAPH = {
+  'lib-1': ['typescript', 'lib-3'],
+  'lib-2': ['react'],
+  'lib-3': [],
+}
+
+const ONE_CYCLE_GRAPH = {
+  'lib-1': ['typescript', 'lib-3'],
+  'lib-2': ['react'],
+  'lib-3': ['lib-1'],
+}
+
+const TWO_CYCLES_GRAPH = {
+  'lib-1': ['typescript', 'lib-3'],
+  'lib-2': ['react'],
+  'lib-3': ['lib-1', 'lib-4'],
+  'lib-4': ['lib-3'],
+}
+
+const LONG_CYCLE_GRAPH = {
+  'lib-1': ['typescript', 'lib-3'],
+  'lib-2': ['react'],
+  'lib-3': ['lib-4'],
+  'lib-4': ['lib-5', 'lib-2'],
+  'lib-5': ['lib-1'],
+}
+
+describe('getGraphCyclePaths', () => {
+  it('returns no cycle paths', () => {
+    expect(getGraphCyclePaths(NO_CYCLES_GRAPH)).toEqual([])
+  })
+
+  it('returns one cycle path', () => {
+    expect(getGraphCyclePaths(ONE_CYCLE_GRAPH)).toEqual([
+      ['lib-1', 'lib-3', 'lib-1'],
+    ])
+  })
+
+  it('returns two cycles paths', () => {
+    expect(getGraphCyclePaths(TWO_CYCLES_GRAPH)).toEqual([
+      ['lib-1', 'lib-3', 'lib-1'],
+      ['lib-3', 'lib-4', 'lib-3'],
+    ])
+  })
+
+  it('returns long cycle path', () => {
+    expect(getGraphCyclePaths(LONG_CYCLE_GRAPH)).toEqual([
+      ['lib-1', 'lib-3', 'lib-4', 'lib-5', 'lib-1'],
+    ])
+  })
+})

package/src/utils/get-lerna-graph.test.js

@@ -0,0 +1,73 @@
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+}))
+
+const { execSync } = require('child_process')
+
+const getLernaGraph = require('./get-lerna-graph')
+
+const graph = {
+  package1: ['externalDependency1', 'package2'],
+  package2: ['externalDependency2', 'externalDependency3'],
+}
+
+describe('getLernaGraph', () => {
+  afterEach(() => {
+    execSync.mockReset()
+  })
+
+  it('executes the command', () => {
+    execSync.mockReturnValue(JSON.stringify(graph))
+
+    getLernaGraph()
+
+    expect(execSync).toHaveBeenCalledTimes(1)
+    expect(execSync).toHaveBeenCalledWith(
+      'yarn --silent --cwd=../.. lerna list --all --toposort --graph --loglevel silent'
+    )
+  })
+
+  it('returns a graph', () => {
+    execSync.mockReturnValue(JSON.stringify(graph))
+
+    const result = getLernaGraph()
+
+    expect(result).toEqual(graph)
+  })
+
+  describe('when onlyLocalDependencies option is true', () => {
+    it('returns graph with only internal dependencies', () => {
+      execSync.mockReturnValue(JSON.stringify(graph))
+
+      const result = getLernaGraph({ onlyLocalDependencies: true })
+
+      expect(result).toEqual({ package1: ['package2'], package2: [] })
+    })
+  })
+
+  describe('when there are some excluded packages', () => {
+    it('returns graph without excluded packages', () => {
+      execSync.mockReturnValue(
+        JSON.stringify({
+          package1: ['externalDependency1', 'package2'],
+          package2: [
+            'externalDependency2',
+            'externalDependency3',
+            'packageToExclude2',
+          ],
+          packageToExclude1: ['package1'],
+          packageToExclude2: [],
+        })
+      )
+
+      const result = getLernaGraph({
+        excludedPackages: new Set(['packageToExclude1', 'packageToExclude2']),
+      })
+
+      expect(result).toEqual({
+        package1: ['externalDependency1', 'package2'],
+        package2: ['externalDependency2', 'externalDependency3'],
+      })
+    })
+  })
+})

package/src/utils/get-packages.test.js

@@ -0,0 +1,78 @@
+const glob = require('glob')
+const fs = require('fs')
+
+const getPackages = require('./get-packages')
+
+const PKG_1 = {
+  name: 'pkg-1',
+}
+
+const PKG_2 = {
+  name: 'pkg-2',
+}
+
+jest.mock(
+  'test-project/package.json',
+  () => ({
+    workspaces: ['packages/*'],
+  }),
+  { virtual: true }
+)
+
+jest.mock('test-project/packages/pkg-1/package.json', () => PKG_1, {
+  virtual: true,
+})
+
+jest.mock('test-project/packages/pkg-2/package.json', () => PKG_2, {
+  virtual: true,
+})
+
+describe('getPackages', () => {
+  const mockWorkspaces = ['packages/pkg-1', 'packages/pkg-2']
+  let fsExistsSyncMock
+  let globSyncMock
+
+  beforeEach(() => {
+    fsExistsSyncMock = jest.spyOn(fs, 'existsSync')
+    globSyncMock = jest.spyOn(glob, 'sync')
+  })
+
+  afterEach(() => {
+    fsExistsSyncMock.mockRestore()
+    globSyncMock.mockRestore()
+  })
+
+  it('gets packages correctly', () => {
+    fsExistsSyncMock.mockImplementation(() => true)
+    globSyncMock.mockImplementation(() => mockWorkspaces)
+
+    const result = [
+      {
+        ...PKG_1,
+        location: mockWorkspaces[0],
+      },
+      {
+        ...PKG_2,
+        location: mockWorkspaces[1],
+      },
+    ]
+
+    expect(getPackages('./test-project')).toEqual(result)
+  })
+
+  it('ignores packages without package json', () => {
+    fsExistsSyncMock.mockImplementation(path =>
+      path.includes('pkg-2/package.json')
+    )
+    globSyncMock.mockImplementation(() => mockWorkspaces)
+
+    const result = [
+      {
+        ...PKG_2,
+        location: mockWorkspaces[1],
+      },
+    ]
+
+    expect(getPackages('./test-project')).toEqual(result)
+  })
+})

package/src/utils/get-workspaces.test.js

@@ -0,0 +1,65 @@
+const glob = require('glob')
+const fs = require('fs')
+
+const getWorkspaces = require('./get-workspaces')
+
+const LIB_1 = {
+  name: 'lib-1',
+  dependencies: { typescript: '4.2.0' },
+}
+
+const LIB_2 = {
+  name: 'lib-2',
+  dependencies: { react: '17.0.0' },
+}
+
+jest.mock(
+  'test-project/package.json',
+  () => ({
+    workspaces: ['libs/*'],
+  }),
+  { virtual: true }
+)
+
+jest.mock('test-project/libs/lib-1/package.json', () => LIB_1, {
+  virtual: true,
+})
+
+jest.mock('test-project/libs/lib-2/package.json', () => LIB_2, {
+  virtual: true,
+})
+
+describe('getWorkspaces', () => {
+  let fsExistsSyncMock
+  let globSyncMock
+
+  beforeEach(() => {
+    fsExistsSyncMock = jest.spyOn(fs, 'existsSync')
+    globSyncMock = jest.spyOn(glob, 'sync')
+  })
+
+  afterEach(() => {
+    fsExistsSyncMock.mockRestore()
+    globSyncMock.mockRestore()
+  })
+
+  it('gets workspaces correctly', () => {
+    fsExistsSyncMock.mockImplementation(() => true)
+    globSyncMock.mockImplementation(() => ['libs/lib-1', 'libs/lib-2'])
+
+    expect(getWorkspaces('./test-project')).toEqual([LIB_1, LIB_2])
+  })
+
+  it('ignores workspaces without package json', () => {
+    fsExistsSyncMock.mockImplementation(path => {
+      if (path.includes('lib-1/package.json')) {
+        return false
+      }
+
+      return true
+    })
+    globSyncMock.mockImplementation(() => ['libs/lib-1', 'libs/lib-2'])
+
+    expect(getWorkspaces('./test-project')).toEqual([LIB_2])
+  })
+})

package/src/utils/make-workspaces-graph.test.js

@@ -0,0 +1,48 @@
+const makeWorkspacesGraph = require('./make-workspaces-graph')
+
+const workspaces = [
+  {
+    name: 'lib-1',
+    dependencies: { typescript: '4.2.0', 'lib-3': '1.0.0' },
+  },
+  {
+    name: 'lib-2',
+    dependencies: { react: '17.0.0' },
+  },
+  {
+    name: 'lib-3',
+  },
+]
+
+describe('makeWorkspacesGraph', () => {
+  it('makes a graph from workspaces', () => {
+    expect(makeWorkspacesGraph(workspaces)).toEqual({
+      'lib-1': ['typescript', 'lib-3'],
+      'lib-2': ['react'],
+      'lib-3': [],
+    })
+  })
+
+  it('includes dev dependencies in a generated graph from workspaces', () => {
+    const workspacesWithDevDeps = [
+      {
+        name: 'lib-1',
+        dependencies: { react: '17.0.0' },
+        devDependencies: { 'react-dom': '18.0.0' },
+      },
+      {
+        name: 'lib-2',
+        devDependencies: { lodash: '4.0.1' },
+      },
+      {
+        name: 'lib-3',
+      },
+    ]
+
+    expect(makeWorkspacesGraph(workspacesWithDevDeps)).toEqual({
+      'lib-1': ['react', 'react-dom'],
+      'lib-2': ['lodash'],
+      'lib-3': [],
+    })
+  })
+})