move type tests into separate directory

test/types/every.mjs

@@ -0,0 +1,13 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: is.every(['', ''], 'string'), expect: true },
+  { fn: is.every(['', ''], is.str), expect: true },
+  { fn: is.every(['', ''], is.num), expect: false },
+  { fn: is.every([() => {}, () => {}], is.fn), expect: true },
+  { fn: is.every([() => {}, () => {}], is.str), expect: false },
+  { fn: is.every('', is.str), expect: true },
+  { fn: is.every('', is.num), expect: false },
+  { fn: is.every('', 'string'), expect: true },
+  { fn: is.every('', 'number'), expect: false },
+]

test/types/instanceof.mjs

@@ -0,0 +1,10 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: is.instance(new Date(), Date), expect: true, info: 'is.instance returns true for Date' },
+  {
+    fn: is.instance(new Date(), RegExp),
+    expect: false,
+    info: 'is.instance returns false for new Date() compared to RegExp',
+  },
+]

test/types/isBuffer.mjs

@@ -0,0 +1,14 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isBuffer(Buffer.from('test', 'utf8')), expect: true },
+  { fn: () => is.buffer(Buffer.from('test', 'utf8')), expect: true },
+  { fn: () => is.buff(Buffer.from('test', 'utf8')), expect: true },
+  { fn: () => is.buff('string'), expect: false },
+  { fn: () => is.buff([]), expect: false },
+  { fn: () => is.buff(0), expect: false },
+  { fn: () => is.buff(['test']), expect: false },
+  { fn: () => is.buff({ copy: true }), expect: false },
+  { fn: () => is.buff({ slice: true }), expect: false },
+  { fn: () => is.buff({ slice: () => {}, copy: () => {} }), expect: false },
+]

test/types/isCase.mjs

@@ -0,0 +1,31 @@
+import is, { isLowerCase, isUpperCase } from '../../src/index.mjs'
+
+const up = 'UPPERCASE'
+const low = 'lowercase'
+
+export default [
+  { fn: isLowerCase(low), expect: true, info: 'isLowerCase is correct for lowercase strings' },
+  { fn: isLowerCase(up), expect: false, info: 'isLowerCase is correct for uppercase strings' },
+
+  { fn: isUpperCase(up), expect: true, info: 'isUpperCase is correct for uppercase strings' },
+  { fn: isUpperCase(low), expect: false, info: 'isUpperCase is correct for lowercase strings' },
+
+  { fn: isLowerCase(23), expect: false, info: 'isLowerCase numbers return false' },
+  { fn: isLowerCase([]), expect: false, info: 'isLowerCase arrays return false' },
+  { fn: isLowerCase({}), expect: false, info: 'isLowerCase objects return false' },
+
+  { fn: isUpperCase(23), expect: false, info: 'isUpperCase numbers return false' },
+  { fn: isUpperCase([]), expect: false, info: 'isUpperCase arrays return false' },
+  { fn: isUpperCase({}), expect: false, info: 'isUpperCase objects return false' },
+
+  { fn: is.case(low, 'low'), expect: true, info: 'is.case is correct for lowercase strings as up' },
+  {
+    fn: is.case(up, 'low'),
+    expect: false,
+    info: 'is.case is correct for uppercase strings as low',
+  },
+  { fn: is.case(up, 'up'), expect: true, info: 'is.case is correct for uppercase strings as up' },
+  { fn: is.case(low, 'up'), expect: false, info: 'is.case is correct for lowercase strings as up' },
+  { fn: is.case(up), expect: true, info: 'default checks for uppercase' },
+  { fn: is.case(low), expect: false, info: 'default checks for uppercase' },
+]

test/types/isComparable.mjs

@@ -0,0 +1,15 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.comparable, expect: is.function },
+  { fn: () => is.isComparable, expect: is.function },
+  { fn: () => is.Comparable, expect: is.function },
+  { fn: () => is.comparable(''), expect: true },
+  { fn: () => is.comparable(9), expect: true },
+  { fn: () => is.comparable(true), expect: true },
+  { fn: () => is.comparable(false), expect: true },
+  { fn: () => is.comparable(), expect: false },
+  { fn: () => is.comparable(null), expect: false },
+  { fn: () => is.comparable({}), expect: false },
+  { fn: () => is.comparable([]), expect: false },
+]

test/types/isDefined.mjs

@@ -0,0 +1,26 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isDefined([1, 2, 3]), expect: true },
+  { fn: () => is.isDef([1, 2, 3]), expect: true },
+  { fn: () => is.defined([1, 2, 3]), expect: true },
+  { fn: () => is.def([1, 2, 3]), expect: true },
+  { fn: () => is.def(true), expect: true },
+  { fn: () => is.def(false), expect: true },
+  { fn: () => is.def('true'), expect: true },
+  { fn: () => is.def(0), expect: true },
+  { fn: () => is.def(''), expect: true },
+  { fn: () => is.def([]), expect: true },
+  { fn: () => is.def(() => {}), expect: true },
+  { fn: () => is.def(1.1), expect: true },
+  { fn: () => is.def(0), expect: true },
+  { fn: () => is.def({ t: 't' }), expect: true },
+  { fn: () => is.def('string'), expect: true },
+  { fn: () => is.def('m@m.m'), expect: true },
+  { fn: () => is.def(/test/), expect: true },
+  { fn: () => is.def(null), expect: true },
+  { fn: () => is.def(new Date()), expect: true },
+  { fn: () => is.def(new Error('test')), expect: true },
+  { fn: () => is.def(), expect: false },
+  { fn: () => is.def(undefined), expect: false },
+]

test/types/isEmail.mjs

@@ -0,0 +1,12 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isEmail('test@example.com'), expect: true },
+  { fn: () => is.email('test@example.com'), expect: true },
+  { fn: () => is.mail('test@example.com'), expect: true },
+  { fn: () => is.isEmail('tes@t@example.com'), expect: true },
+  { fn: () => is.isEmail('testmail.com'), expect: false },
+  { fn: () => is.isEmail(''), expect: false },
+  { fn: () => is.isEmail([]), expect: false },
+  { fn: () => is.isEmail({}), expect: false },
+]

test/types/isEmpty.mjs

@@ -0,0 +1,16 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isEmpty(''), expect: true },
+  { fn: () => is.isEmpty(null), expect: true },
+  { fn: () => is.isEmpty(), expect: true },
+  { fn: () => is.isEmpty(new RegExp()), expect: true },
+  { fn: () => is.empty(''), expect: true },
+  { fn: () => is.empty(0), expect: true },
+  { fn: () => is.empty([]), expect: true },
+  { fn: () => is.empty({}), expect: true },
+  { fn: () => is.empty(new Date()), expect: false },
+  { fn: () => is.empty(new Error('test')), expect: false },
+  { fn: () => is.empty(/test/), expect: false },
+  { fn: () => is.empty(new RegExp()), expect: true },
+]

test/types/isFalsy.mjs

@@ -0,0 +1,13 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isFalsy(''), expect: true },
+  { fn: () => is.falsy(''), expect: true },
+  { fn: () => is.falsy(0), expect: true },
+  { fn: () => is.falsy(false), expect: true },
+  { fn: () => is.falsy('false'), expect: false },
+  { fn: () => is.falsy('test'), expect: false },
+  { fn: () => is.falsy(1), expect: false },
+  { fn: () => is.falsy(['test']), expect: false },
+  { fn: () => is.falsy({ t: 't' }), expect: false },
+]

test/types/isIterable.mjs

@@ -0,0 +1,11 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isIterable({ forEach: () => {} }), expect: true },
+  { fn: () => is.isIter({ forEach: () => {} }), expect: true },
+  { fn: () => is.iterable({ forEach: () => {} }), expect: true },
+  { fn: () => is.iter({ forEach: () => {} }), expect: true },
+  { fn: () => is.isIterable([]), expect: true },
+  { fn: () => is.isIterable(Object.keys({})), expect: true },
+  { fn: () => is.isIterable({}), expect: false },
+]

test/types/isMap.mjs

@@ -0,0 +1,11 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: is.map(new Map()), expect: true },
+  { fn: is.map({}), expect: false },
+  { fn: is.map([]), expect: false },
+  { fn: is.map(''), expect: false },
+  { fn: is.map(new Set()), expect: false },
+  { fn: is.map(new WeakSet()), expect: false },
+  { fn: is.map(new WeakMap()), expect: false },
+]

test/types/isMergeable.mjs

@@ -0,0 +1,14 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isMergeable({}), expect: true },
+  { fn: () => is.isMergeableObject({}), expect: true },
+  { fn: () => is.mergeableObject({}), expect: true },
+  { fn: () => is.mergeable({ t: 't' }), expect: true },
+  { fn: () => is.mergeable(), expect: false },
+  { fn: () => is.mergeable(0), expect: false },
+  { fn: () => is.mergeable(() => {}), expect: false },
+  { fn: () => is.mergeable(''), expect: false },
+  { fn: () => is.mergeable(new Date()), expect: false },
+  { fn: () => is.mergeable(/regex/), expect: false },
+]

test/types/isSet.mjs

@@ -0,0 +1,11 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: is.set(new Set()), expect: true },
+  { fn: is.set({}), expect: false },
+  { fn: is.set([]), expect: false },
+  { fn: is.set(''), expect: false },
+  { fn: is.set(new Map()), expect: false },
+  { fn: is.set(new WeakSet()), expect: false },
+  { fn: is.set(new WeakMap()), expect: false },
+]

test/types/isThenable.mjs

@@ -0,0 +1,8 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isThenable({ then: () => {} }), expect: true },
+  { fn: () => is.thenable({ then: () => {} }), expect: true },
+  { fn: () => is.isThenable({}), expect: false },
+  { fn: () => is.isThenable('string'), expect: false },
+]

test/types/isTruthy.mjs

@@ -0,0 +1,13 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isTruthy('test'), expect: true },
+  { fn: () => is.truthy('test'), expect: true },
+  { fn: () => is.truthy(1), expect: true },
+  { fn: () => is.truthy(['test']), expect: true },
+  { fn: () => is.truthy({ t: 't' }), expect: true },
+  { fn: () => is.truthy('false'), expect: true },
+  { fn: () => is.truthy(''), expect: false },
+  { fn: () => is.truthy(0), expect: false },
+  { fn: () => is.truthy(false), expect: false },
+]

test/types/isUUID.mjs

@@ -0,0 +1,18 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isUUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8') },
+  { fn: () => is.uuid('6ba7b810-9dad-11d1-80b4-00c04fd430c8') },
+  { fn: () => is.isUUID('6ba7b811-9dad-11d1-80b4-00c04fd430c8') },
+  { fn: () => is.isUUID('6ba7b812-9dad-11d1-80b4-00c04fd430c8') },
+  { fn: () => is.isUUID('6ba7b814-9dad-11d1-80b4-00c04fd430c8') },
+  { fn: () => is.isUUID('6ba7b812-9dad-11d1-80b4'), expect: false },
+  { fn: () => is.isUUID('6ba7b812-9dad-11d1-80b4-00c04fd430c'), expect: false },
+  { fn: () => is.isUUID('zzzzzzzz-9dad-11d1-80b4-00c04fd430c8'), expect: false },
+  { fn: () => is.isUUID('t920tj22t32-tj2f2f223f23'), expect: false },
+  { fn: () => is.isUUID(), expect: false },
+  { fn: () => is.isUUID(''), expect: false },
+  { fn: () => is.isUUID([]), expect: false },
+  { fn: () => is.isUUID({}), expect: false },
+  { fn: () => is.isUUID(() => {}), expect: false },
+]

test/types/isUnefined.mjs

@@ -0,0 +1,24 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: () => is.isUndefined(undefined), expect: true },
+  { fn: () => is.isUndef(undefined), expect: true },
+  { fn: () => is.undefined(undefined), expect: true },
+  { fn: () => is.undef(undefined), expect: true },
+  { fn: () => is.undef(true), expect: false },
+  { fn: () => is.undef(false), expect: false },
+  { fn: () => is.undef('true'), expect: false },
+  { fn: () => is.undef(0), expect: false },
+  { fn: () => is.undef(''), expect: false },
+  { fn: () => is.undef([]), expect: false },
+  { fn: () => is.undef(() => {}), expect: false },
+  { fn: () => is.undef(1.1), expect: false },
+  { fn: () => is.undef(0), expect: false },
+  { fn: () => is.undef({ t: 't' }), expect: false },
+  { fn: () => is.undef('string'), expect: false },
+  { fn: () => is.undef('m@m.m'), expect: false },
+  { fn: () => is.undef(/test/), expect: false },
+  { fn: () => is.undef(null), expect: false },
+  { fn: () => is.undef(new Date()), expect: false },
+  { fn: () => is.undef(new Error('test')), expect: false },
+]

test/types/isWeakMap.mjs

@@ -0,0 +1,11 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: is.weakMap(new WeakMap()), expect: true },
+  { fn: is.weakMap({}), expect: false },
+  { fn: is.weakMap([]), expect: false },
+  { fn: is.weakMap(''), expect: false },
+  { fn: is.weakMap(new WeakSet()), expect: false },
+  { fn: is.weakMap(new Set()), expect: false },
+  { fn: is.weakMap(new Map()), expect: false },
+]

test/types/length.mjs

@@ -0,0 +1,93 @@
+import is from '../../src/index.mjs'
+
+export default {
+  ident: [
+    { fn: () => is.length([]), expect: 0, info: 'is.length' },
+    { fn: () => is.count([1]), expect: 1, info: 'is.count' },
+    { fn: () => is.len([1, 2]), expect: 2, info: 'is.len' },
+    { fn: () => is.len(new Map([[1, '1']])), expect: 1, info: 'is.len Map' },
+    { fn: () => is.len(new Set([1, 2])), expect: 2, info: 'is.len Set' },
+    { fn: () => is.len(new Set('123')), expect: 3, info: 'Set(string)' },
+    { fn: () => is.len('123'), expect: 3, info: 'is.len String' },
+    { fn: () => is.len({ t: 't' }), expect: 1, info: 'is.len Object' },
+  ],
+  equal: [
+    { fn: () => is.length.equal(3)('123'), info: 'is.length.equal' },
+    { fn: () => is.length.eq(3)('123'), info: 'is.length.eq' },
+    { fn: () => is.count.equal(5)('12345'), info: 'is.count.equal' },
+    { fn: () => is.count.eq(5)('12345'), info: 'is.count.eq' },
+    { fn: () => is.len.equal(4)('1234'), info: 'is.len.equal' },
+    { fn: () => is.len.eq(4)('1234'), info: 'is.len.eq' },
+    { fn: () => is.len.eq(3)(new Set([1, 2, 3])), info: 'Number and Set' },
+    { fn: () => is.len.eq(5)(new Set([1, 2, 3])), expect: false, info: 'Set and Number' },
+    { fn: () => is.len.eq([1, 2, 3], new Set([1, 2, 3])), info: 'Array and Set' },
+    {
+      fn: () =>
+        is.len.eq(
+          new Map([
+            ['1', 1],
+            ['2', 2],
+          ]),
+          new Set([1, 2]),
+        ),
+      info: 'Map and Set',
+    },
+    {
+      fn: () =>
+        is.len.eq(
+          [1, 2],
+          new Map([
+            ['1', 1],
+            ['2', 2],
+          ]),
+        ),
+      info: 'Array and Map',
+    },
+    { fn: () => is.len.eq(new Map([['1', 1]]), new Map([['1', 1]])), info: 'Map and Map' },
+    { fn: () => is.len.eq('123', '123'), info: 'compare strings' },
+    { fn: () => is.len.eq(0)({}), info: 'empty objects' },
+    { fn: () => is.len.eq(0)([]), info: 'empty arrays' },
+    { fn: () => is.len.eq(0)(''), info: 'empty strings' },
+    { fn: () => is.len.eq('')(''), info: 'empty strings' },
+    { fn: () => is.len.eq(3)([1, 2, 3]), info: 'compare arrays' },
+    { fn: () => is.len.eq(1)({ test: 'true ' }), info: 'compare objects' },
+    { fn: () => is.len.eq(1, '1'), info: 'compare uncurried' },
+    { fn: () => is.len.eq(1, { t: 't' }), info: 'compare objects uncurried' },
+    { fn: () => is.len.eq({ t: 1 }, { t: 1 }), info: 'compare objects uncurried' },
+    { fn: () => is.len.eq(3, [1, 2, 3]), info: 'compare  arrays uncurried' },
+    { fn: () => is.len.eq('123', '123'), info: 'compare strings' },
+    { fn: () => is.len.eq(5, '12345'), info: 'compare strings uncurried' },
+    { fn: () => is.len.eq(4, 1234), expect: false, info: 'numbers never count' },
+  ],
+  greater: [
+    // currying
+    { fn: () => is.len.greater, expect: is.function },
+    { fn: () => is.len.gt, expect: is.function },
+    { fn: () => is.len.bigger, expect: is.function },
+    { fn: () => is.len.gt(10), expect: is.function, info: 'can curry' },
+    { fn: () => is.len.gt(10)(5), expect: true, info: 'can compare numbers' },
+    { fn: () => is.len.gt(5)(10), expect: false, info: 'can compare numbers' },
+    { fn: () => is.len.gt([1])([]), expect: true, info: 'can compare arrays' },
+    { fn: () => is.len.gt([])([1]), expect: false, info: 'can compare arrays' },
+    { fn: () => is.len.gt({})({ t: 1 }), expect: false, info: 'can compare objects' },
+    { fn: () => is.len.gt({ t: 1 }, {}), expect: true, info: 'can compare objects' },
+    { fn: () => is.len.gt('12')('1'), expect: true },
+    { fn: () => is.len.gt('1')('12'), expect: false },
+    { fn: () => is.len.gt([1], [1]), expect: false },
+  ],
+  smaller: [
+    { fn: () => is.len.lower, expect: is.function },
+    { fn: () => is.len.lt, expect: is.function },
+    { fn: () => is.len.smaller, expect: is.function },
+    { fn: () => is.len.lt(10), expect: is.function, info: 'can curry' },
+    { fn: () => is.len.lt(10)(5), expect: false, info: 'can compare numbers' },
+    { fn: () => is.len.lt(5)(10), expect: true, info: 'can compare numbers' },
+    { fn: () => is.len.lt([1])([]), expect: false, info: 'can compare arrays' },
+    { fn: () => is.len.lt([])([1]), expect: true, info: 'can compare arrays' },
+    { fn: () => is.len.lt({})({ t: 1 }), expect: true, info: 'can compare objects' },
+    { fn: () => is.len.lt({ t: 1 }, {}), expect: false, info: 'can compare objects' },
+    { fn: () => is.len.lt('12')('1'), expect: false },
+    { fn: () => is.len.lt('1')('12'), expect: true },
+    { fn: () => is.len.lt([1], [1]), expect: false },
+  ],
+}

test/types/none.mjs

@@ -0,0 +1,12 @@
+import is from '../../src/index.mjs'
+
+export default [
+  { fn: is.none(['', ''], 'number'), expect: true },
+  { fn: is.none(['', ''], 'string'), expect: false },
+  { fn: is.none(['', ''], is.str), expect: false },
+  { fn: is.none(['', ''], is.num), expect: true },
+  { fn: is.none([5, ''], is.num), expect: false },
+  { fn: is.none([() => {}, () => {}], is.fn), expect: false },
+  { fn: is.none('', is.str), expect: false },
+  { fn: is.none('', 'string'), expect: false },
+]