fix types verbosity on tests

Author: notanengineercom

spec/RecordedArguments.spec.ts

@@ -20,32 +20,32 @@ test('records values and classifies them correctly', t => {
   const emptyArguments = RecordedArguments.from([])
   t.deepEqual(emptyArguments.value, [])
   t.is(emptyArguments.argumentsClass, 'plain')
-  t.is(emptyArguments.hasNoArguments, false)
+  t.is(emptyArguments.hasArguments(), true)
 
   const primitivesOnlyArguments = RecordedArguments.from([1, 'Substitute', false, testSymbol, undefined, null, testFunc, {}])
   t.deepEqual(primitivesOnlyArguments.value, [1, 'Substitute', false, testSymbol, undefined, null, testFunc, {}])
   t.is(primitivesOnlyArguments.argumentsClass, 'plain')
-  t.is(primitivesOnlyArguments.hasNoArguments, false)
+  t.is(primitivesOnlyArguments.hasArguments(), true)
 
   const anyArg = Arg.any('any')
   const withSingleArgumentArguments = RecordedArguments.from([1, 'Substitute', false, testSymbol, undefined, null, testFunc, {}, anyArg])
   t.deepEqual(withSingleArgumentArguments.value, [1, 'Substitute', false, testSymbol, undefined, null, testFunc, {}, anyArg])
   t.is(withSingleArgumentArguments.argumentsClass, 'with-predicate')
-  t.is(withSingleArgumentArguments.hasNoArguments, false)
+  t.is(withSingleArgumentArguments.hasArguments(), true)
 
   const allArg = Arg.all()
   const allArgumentArguments = RecordedArguments.from([allArg])
   t.deepEqual(allArgumentArguments.value, [allArg])
   t.is(allArgumentArguments.argumentsClass, 'wildcard')
-  t.is(allArgumentArguments.hasNoArguments, false)
+  t.is(allArgumentArguments.hasArguments(), true)
 })
 
 test('creates a valid instance for no arguments', t => {
   const args = RecordedArguments.none()
 
   t.is(args.value, undefined)
   t.is(args.argumentsClass, undefined)
-  t.is(args.hasNoArguments, true)
+  t.is(args.hasArguments(), false)
 })
 
 test('sorts correctly objects with RecordedArguments', t => {

spec/Recorder.spec.ts

@@ -40,11 +40,11 @@ test('indexes all records correctly', t => {
 
   const nodeSet = recorder.indexedRecords.get(node.key)
   t.true(nodeSet instanceof RecordsSet)
-  t.deepEqual([...nodeSet], [node])
+  t.deepEqual([...nodeSet!], [node])
 
   const otherNodeSet = recorder.indexedRecords.get(otherNode.key)
   t.true(otherNodeSet instanceof RecordsSet)
-  t.deepEqual([...otherNodeSet], [otherNode, otherNodeDifferentInstance])
+  t.deepEqual([...otherNodeSet!], [otherNode, otherNodeDifferentInstance])
 })
 
 test('returns all sibling nodes', t => {
@@ -71,7 +71,7 @@ test('clears recorded nodes by a given filter function', t => {
 
   recorder.clearRecords(n => n.key === otherNode.key)
   t.deepEqual([...recorder.records], [node])
-  t.deepEqual([...recorder.indexedRecords.get(node.key)], [node])
+  t.deepEqual([...recorder.indexedRecords.get(node.key)!], [node])
   t.is(recorder.indexedRecords.get(otherNode.key), undefined)
 
   recorder.clearRecords(_ => true)

spec/regression/Arguments.spec.ts

@@ -18,8 +18,8 @@ test('should match any argument(s) using Arg.all', t => {
   t.true(Arg.all().matches(['string']))
   t.true(Arg.all().matches([true]))
   t.true(Arg.all().matches([false]))
-  t.true(Arg.all().matches(null))
-  t.true(Arg.all().matches(undefined))
+  t.true(Arg.all().matches([null]))
+  t.true(Arg.all().matches([undefined]))
   t.true(Arg.all().matches([1, 2]))
   t.true(Arg.all().matches(['string1', 'string2']))
 })
@@ -74,7 +74,7 @@ test('should match the type of the argument using Arg.any', t => {
 
   t.false((<Argument<unknown>>Arg.any('string')).matches(1))
   t.false((<Argument<unknown>>Arg.any('number')).matches('string'))
-  t.false(Arg.any('boolean').matches(null))
+  t.false((<Argument<unknown>>Arg.any('boolean')).matches(null))
   t.false((<Argument<unknown>>Arg.any('object')).matches('foo'))
   t.false((<Argument<unknown>>Arg.any('array')).matches('bar'))
   t.false((<Argument<unknown>>Arg.any('function')).matches('foo'))

spec/regression/index.test.ts

@@ -1,7 +1,6 @@
 import test from 'ava'
 
-import { Substitute, Arg } from '../../src'
-import { OmitProxyMethods, ObjectSubstitute } from '../../src/Transformations'
+import { Substitute, Arg, SubstituteOf } from '../../src'
 
 class Dummy {
 
@@ -34,12 +33,12 @@ export class Example {
 	}
 
 	bar(a: number, b?: number): number {
-		return a + b || 0
+		return a + (b ?? 0)
 	}
 }
 
 let instance: Example
-let substitute: ObjectSubstitute<Example>
+let substitute: SubstituteOf<Example>
 
 function initialize() {
 	instance = new Example()
@@ -69,21 +68,26 @@ test('class with method called \'received\' can be used for call count verificat
 test('class string field set received', t => {
 	initialize()
 
-	substitute.v = undefined
-	substitute.v = null
-	substitute.v = 'hello'
-	substitute.v = 'hello'
-	substitute.v = 'world'
+	const runLogic = (example: Example) => {
+		example.v = undefined
+		example.v = null
+		example.v = 'hello'
+		example.v = 'hello'
+		example.v = 'world'
+	}
+
+	runLogic(substitute)
+
 
 	t.notThrows(() => substitute.received().v = 'hello')
 	t.notThrows(() => substitute.received(5).v = Arg.any())
 	t.notThrows(() => substitute.received().v = Arg.any())
 	t.notThrows(() => substitute.received(2).v = 'hello')
-	t.notThrows(() => substitute.received(2).v = Arg.is(x => x && x.indexOf('ll') > -1))
+	t.notThrows(() => substitute.received(2).v = Arg.is(x => typeof x === 'string' && x.indexOf('ll') > -1))
 
 	t.throws(() => substitute.received(2).v = Arg.any())
 	t.throws(() => substitute.received(1).v = Arg.any())
-	t.throws(() => substitute.received(1).v = Arg.is(x => x && x.indexOf('ll') > -1))
+	t.throws(() => substitute.received(1).v = Arg.is(x => typeof x === 'string' && x.indexOf('ll') > -1))
 	t.throws(() => substitute.received(3).v = 'hello')
 })
 

spec/regression/issues/36.test.ts

@@ -42,6 +42,7 @@ class Service {
         await this._database.storeUpdates(updateData)
     }
     private getData(arg?: Key) {
+        if (typeof arg === 'undefined') throw new TypeError('Key is undefined')
         return this._database.getUpdates(arg)
     }
 }

spec/regression/mimicks.spec.ts

@@ -43,7 +43,7 @@ test('mimicks a method with Arg.all', t => {
 test('mimicks a method with optional arguments', t => {
   const calculator = Substitute.for<Calculator>()
   const multiplyOneArgMimicks = (a: number) => a * a
-  const multiplyMimicks = (a: number, b?: number) => a * b
+  const multiplyMimicks = (a: number, b?: number) => a * (b ?? 0)
 
   calculator.multiply(0, Arg.is((b: number) => b > 10 && b < 20)).mimicks(multiplyMimicks)
   calculator.multiply(Arg.any('number'), Arg.is((b: number) => b === 2)).mimicks(multiplyMimicks)

spec/regression/received.spec.ts

@@ -64,8 +64,11 @@ test('getting a property twice correctly asserts the call count', t => {
 
 test('setting a property twice correctly asserts the call count', t => {
   const calculator = Substitute.for<Calculator>()
-  calculator.isEnabled = true
-  calculator.isEnabled = true
+  const runLogic = (calc: Calculator) => {
+    calc.isEnabled = true
+    calc.isEnabled = true
+  }
+  runLogic(calculator)
 
   calculator.received(2).isEnabled = true
   calculator.received().isEnabled = true

spec/regression/returns.spec.ts

@@ -7,16 +7,21 @@ interface Calculator {
   add(a: number, b: number): number
   multiply(a: number, b?: number): number
   clear(): void
+  other(): Calculator
   getMemory(): Promise<number>
   viewResult(back?: number): number
   heavyOperation(...input: number[]): Promise<boolean>
   isEnabled: boolean
+  isEnabled2: Calculator
   model: Promise<string>
 };
 
 test('returns a primitive value for method with no arguments', t => {
   const calculator = Substitute.for<Calculator>()
   calculator.clear().returns()
+  // calculator.add(1, 2).toExponential()
+  // calculator.isEnabled2.viewResult().returns(3)
+  // calculator.other().viewResult().returns(2)
 
   t.is(calculator.clear(), void 0)
 })