refactor(Cypress): add nodemodules

node_modules/undeclared-identifiers/test/index.js

@@ -0,0 +1,258 @@
+var test = require('tape')
+var acorn = require('acorn-node')
+var find = require('../')
+
+test('undeclared variables', function (t) {
+  t.deepEqual(find(`
+    var a, b
+    a, b, c
+  `), {
+    identifiers: ['c'],
+    properties: []
+  })
+  t.end()
+})
+
+test('pass in a parsed ast', function (t) {
+  t.deepEqual(find(acorn.parse(`
+    var a, b
+    a, b, c
+  `)), {
+    identifiers: ['c'],
+    properties: []
+  })
+  t.end()
+})
+
+test('undeclared properties', function (t) {
+  t.deepEqual(find(`
+    var a, b
+    a, b, c, d.e
+  `), {
+    identifiers: ['c', 'd'],
+    properties: ['d.e']
+  })
+  t.end()
+})
+
+test('wildcard use of undeclared name', function (t) {
+  t.deepEqual(find(`
+    function func () {}
+    new A()
+    A.from()
+    func(b)
+    C.from()
+  `, { wildcard: true }), {
+    identifiers: ['A', 'b', 'C'],
+    properties: ['A.*', 'A.from', 'b.*', 'C.from']
+  })
+  t.end()
+})
+
+test('wildcard use of undeclared name (different order)', function (t) {
+  t.deepEqual(find(`
+    A.from()
+    new A()
+  `, { wildcard: true }), {
+    identifiers: ['A'],
+    properties: ['A.from', 'A.*']
+  })
+  t.end()
+})
+
+test('function names', function (t) {
+  t.deepEqual(find(`
+    function x () {
+      return x
+    }
+    x()
+  `), {
+    identifiers: [],
+    properties: []
+  })
+  t.deepEqual(find(`
+    function x () {
+      return x
+    }
+    y()
+  `), {
+    identifiers: ['y'],
+    properties: []
+  })
+  t.end()
+})
+
+test('class names', function (t) {
+  t.deepEqual(find(`
+    class X {}
+    new X()
+  `), {
+    identifiers: [],
+    properties: []
+  })
+  t.deepEqual(find(`
+    class X extends Y {}
+    new X()
+  `), {
+    identifiers: ['Y'],
+    properties: []
+  })
+  t.deepEqual(find(`
+    class Y {}
+    class X extends Y {}
+    new X()
+  `), {
+    identifiers: [],
+    properties: []
+  })
+  t.end()
+})
+
+test('class methods', function (t) {
+  t.deepEqual(find(`
+    class X {
+      constructor() { u }
+      bar() { v }
+      static foo() { w }
+    }
+  `), {
+    identifiers: ['u', 'v', 'w'],
+    properties: []
+  })
+  t.end()
+})
+
+test('super', function (t) {
+  t.deepEqual(find(`
+    class X extends Y {
+      constructor() { super() }
+    }
+  `), {
+    identifiers: ['Y'],
+    properties: []
+  })
+  t.deepEqual(find(`
+    class X {
+      foo() { super.foo }
+    }
+  `), {
+    identifiers: [],
+    properties: []
+  })
+  t.end()
+})
+
+test('scope', function (t) {
+  t.deepEqual(find(`
+    function y () {
+      function x () {
+        return x
+      }
+    }
+    x(y(x.y))
+  `), {
+    identifiers: ['x'],
+    properties: ['x.y']
+  })
+  t.end()
+})
+
+test('block scope', function (t) {
+  t.deepEqual(find(`
+    var x
+    { var y; let z }
+    x, y, z
+  `), {
+    identifiers: ['z'],
+    properties: []
+  })
+  t.end()
+})
+
+test('function parameters', function (t) {
+  t.deepEqual(find(`
+    function a (a1, a2) { a, a1, a2, a3 }
+    ;(function b (b1, b2) { b, b1, b2, b3 })
+    ;((c1, c2) => { c1, c2, c3 })
+  `), {
+    identifiers: ['a3', 'b3', 'c3'],
+    properties: []
+  })
+  t.deepEqual(find(`
+    function a (a1, a2) { }
+    a, a1, a2
+  `), {
+    identifiers: ['a1', 'a2'],
+    properties: []
+  })
+  t.end()
+})
+
+test('assignment', function (t) {
+  t.deepEqual(find(`
+    var a
+    b = 2
+    b.c = 3
+  `), {
+    identifiers: ['b'],
+    properties: ['b.c']
+  })
+  t.end()
+})
+
+test('catch', function (t) {
+  t.deepEqual(find(`
+    try { var a } catch (err) { err }
+    try { let b } catch (orr) { orr }
+    a, b
+  `), {
+    identifiers: ['b'],
+    properties: []
+  })
+  t.end()
+})
+
+test('object prototype names', function (t) {
+  t.deepEqual(find(`
+    var propertyIsEnumerable, hasOwnProperty
+    isPrototypeOf
+  `), {
+    identifiers: ['isPrototypeOf'],
+    properties: []
+  })
+  t.end()
+})
+
+test('labels', function (t) {
+  t.deepEqual(find(`
+    a: a;
+    b: a;
+    c: a;
+  `), {
+    identifiers: ['a'],
+    properties: []
+  })
+  t.end()
+})
+
+test('property keys', function (t) {
+  t.deepEqual(find(`
+    ({ a: a,
+    b: a, [d]: a,
+    c: a, })
+  `), {
+    identifiers: ['a', 'd'],
+    properties: []
+  })
+  t.end()
+})
+
+test('string property access', function (t) {
+  t.deepEqual(find(`
+    Buffer["isBuffer"]
+  `), {
+    identifiers: ['Buffer'],
+    properties: ['Buffer.isBuffer']
+  })
+  t.end()
+})