How to use wrapConstructorNameAroundOutput method in unexpected

Best JavaScript code snippet using unexpected

assertions.js

Source:assertions.js

...460                ) {461                  actual[propertyName] = subject[propertyName];462                }463              });464              return utils.wrapConstructorNameAroundOutput(465                diff(actual, expected),466                subject467              );468            },469          });470        }471      );472    }473  );474  expect.addAssertion(475    '<string|array-like> [not] to have length <number>',476    (expect, subject, length) => {477      if (!expect.flags.not) {478        expect.errorMode = 'nested';479      }480      expect(subject.length, '[not] to be', length);481    }482  );483  expect.addAssertion(484    '<string|array-like> [not] to be empty',485    (expect, subject) => {486      expect(subject, '[not] to have length', 0);487    }488  );489  expect.addAssertion(490    '<string|array-like|object> to be non-empty',491    (expect, subject) => {492      expect(subject, 'not to be empty');493    }494  );495  expect.addAssertion(496    '<object> to [not] [only] have keys <array>',497    (expect, subject, keys) => {498      const keysInSubject = {};499      const subjectType = expect.findTypeOf(subject);500      const subjectKeys = subjectType.getKeys(subject);501      subjectKeys.forEach((key) => {502        keysInSubject[key] = true;503      });504      if (expect.flags.not && keys.length === 0) {505        return;506      }507      const hasKeys = keys.every((key) => keysInSubject[key]);508      if (expect.flags.only) {509        expect(hasKeys, 'to be truthy');510        expect.withError(511          () => {512            expect(subjectKeys.length === keys.length, '[not] to be truthy');513          },514          () => {515            expect.fail({516              diff:517                !expect.flags.not &&518                ((output, diff, inspect, equal) => {519                  output.inline = true;520                  const keyInValue = {};521                  keys.forEach((key) => {522                    keyInValue[key] = true;523                  });524                  const subjectIsArrayLike = subjectType.is('array-like');525                  subjectType.prefix(output, subject);526                  output.nl().indentLines();527                  subjectKeys.forEach((key, index) => {528                    const propertyOutput = subjectType.property(529                      output.clone(),530                      key,531                      inspect(subjectType.valueForKey(subject, key)),532                      subjectIsArrayLike533                    );534                    const delimiterOutput = subjectType.delimiter(535                      output.clone(),536                      index,537                      subjectKeys.length538                    );539                    output540                      .i()541                      .block(function () {542                        this.append(propertyOutput).amend(delimiterOutput);543                        if (!keyInValue[key]) {544                          this.sp().annotationBlock(function () {545                            this.error('should be removed');546                          });547                        }548                      })549                      .nl();550                  });551                  output.outdentLines();552                  subjectType.suffix(output, subject);553                  return output;554                }),555            });556          }557        );558      } else {559        expect(hasKeys, '[not] to be truthy');560      }561    }562  );563  expect.addAssertion('<object> [not] to be empty', (expect, subject) => {564    if (565      expect.flags.not &&566      !expect.findTypeOf(subject).getKeys(subject).length567    ) {568      return expect.fail();569    }570    expect(subject, 'to [not] only have keys', []);571  });572  expect.addAssertion(573    '<object> not to have keys <array>',574    (expect, subject, keys) => {575      expect(subject, 'to not have keys', keys);576    }577  );578  expect.addAssertion(579    '<object> not to have key <string>',580    (expect, subject, value) => {581      expect(subject, 'to not have keys', [value]);582    }583  );584  expect.addAssertion(585    '<object> not to have keys <string+>',586    function (expect, subject, value) {587      expect(588        subject,589        'to not have keys',590        Array.prototype.slice.call(arguments, 2)591      );592    }593  );594  expect.addAssertion(595    '<object> to [not] [only] have key <string>',596    (expect, subject, value) => {597      expect(subject, 'to [not] [only] have keys', [value]);598    }599  );600  expect.addAssertion(601    '<object> to [not] [only] have keys <string+>',602    function (expect, subject) {603      expect(604        subject,605        'to [not] [only] have keys',606        Array.prototype.slice.call(arguments, 2)607      );608    }609  );610  expect.addAssertion(611    '<string> [not] to contain <string+>',612    function (expect, subject) {613      const args = Array.prototype.slice.call(arguments, 2);614      args.forEach((arg) => {615        if (arg === '') {616          throw new Error(617            `The '${expect.testDescription}' assertion does not support the empty string`618          );619        }620      });621      expect.withError(622        () => {623          args.forEach((arg) => {624            expect(subject.indexOf(arg) !== -1, '[not] to be truthy');625          });626        },627        (e) => {628          expect.fail({629            diff(output) {630              output.inline = false;631              let lastIndex = 0;632              function flushUntilIndex(i) {633                if (i > lastIndex) {634                  output.text(subject.substring(lastIndex, i));635                  lastIndex = i;636                }637              }638              if (expect.flags.not) {639                subject.replace(640                  new RegExp(641                    args642                      .map((arg) => utils.escapeRegExpMetaChars(arg))643                      .join('|'),644                    'g'645                  ),646                  ($0, index) => {647                    flushUntilIndex(index);648                    lastIndex += $0.length;649                    output.removedHighlight($0);650                  }651                );652                flushUntilIndex(subject.length);653              } else {654                const ranges = [];655                args.forEach((arg) => {656                  let needle = arg;657                  let partial = false;658                  while (needle.length > 1) {659                    let found = false;660                    lastIndex = -1;661                    let index;662                    do {663                      index = subject.indexOf(needle, lastIndex + 1);664                      if (index !== -1) {665                        found = true;666                        ranges.push({667                          startIndex: index,668                          endIndex: index + needle.length,669                          partial,670                        });671                      }672                      lastIndex = index;673                    } while (lastIndex !== -1);674                    if (found) {675                      break;676                    }677                    needle = arg.substr(0, needle.length - 1);678                    partial = true;679                  }680                });681                lastIndex = 0;682                ranges683                  .sort((a, b) => a.startIndex - b.startIndex)684                  .forEach(({ startIndex, endIndex, partial }) => {685                    flushUntilIndex(startIndex);686                    const firstUncoveredIndex = Math.max(startIndex, lastIndex);687                    if (endIndex > firstUncoveredIndex) {688                      if (partial) {689                        output.partialMatch(690                          subject.substring(firstUncoveredIndex, endIndex)691                        );692                      } else {693                        output.match(694                          subject.substring(firstUncoveredIndex, endIndex)695                        );696                      }697                      lastIndex = endIndex;698                    }699                  });700                flushUntilIndex(subject.length);701              }702              return output;703            },704          });705        }706      );707    }708  );709  expect.addAssertion(710    [711      '<array-like> to [only] contain <any+>',712      '<array-like> [not] to contain <any+>',713    ],714    function (expect, subject) {715      const args = Array.prototype.slice.call(arguments, 2);716      expect.withError(717        () => {718          args.forEach((arg) => {719            expect(720              Array.prototype.some.call(subject, (item) =>721                expect.equal(item, arg)722              ),723              '[not] to be truthy'724            );725          });726          if (expect.flags.only) {727            expect(728              Array.prototype.every.call(subject, (item) =>729                Array.prototype.some.call(args, (arg) =>730                  expect.equal(item, arg)731                )732              ),733              'to be truthy'734            );735          }736        },737        (e) => {738          expect.fail({739            diff(output, diff, inspect, equal) {740              if (expect.flags.not) {741                return diff(742                  subject,743                  Array.prototype.filter.call(744                    subject,745                    (item) => !args.some((arg) => equal(item, arg))746                  )747                );748              } else if (expect.flags.only) {749                const excessItems = Array.prototype.filter.call(750                  subject,751                  (item) => args.some((arg) => equal(item, arg))752                );753                const missingItems = args.filter(754                  (arg) =>755                    !Array.prototype.some.call(subject, (item) =>756                      equal(arg, item)757                    )758                );759                return diff(subject, [...excessItems, ...missingItems]);760              }761            },762          });763        }764      );765    }766  );767  expect.addAssertion(768    [769      '<string> [not] to begin with <string>',770      '<string> [not] to start with <string>',771    ],772    (expect, subject, value) => {773      if (value === '') {774        throw new Error(775          `The '${expect.testDescription}' assertion does not support a prefix of the empty string`776        );777      }778      let isTruncated = false;779      let outputSubject = utils.truncateSubjectStringForBegin(subject, value);780      if (outputSubject === null) {781        outputSubject = subject;782      } else {783        isTruncated = true;784      }785      expect.subjectOutput = (output) => {786        output = output.jsString(787          "'" + outputSubject.replace(/\n/g, '\\n') + "'"788        );789        if (isTruncated) {790          output.jsComment('...');791        }792      };793      expect.withError(794        () => {795          expect(subject.substr(0, value.length), '[not] to equal', value);796        },797        () => {798          expect.fail({799            diff(output) {800              output.inline = false;801              if (expect.flags.not) {802                output803                  .removedHighlight(value)804                  .text(subject.substr(value.length));805              } else {806                let i = 0;807                while (subject[i] === value[i]) {808                  i += 1;809                }810                if (i === 0) {811                  // No common prefix, omit diff812                  return null;813                } else {814                  output815                    .partialMatch(subject.substr(0, i))816                    .text(outputSubject.substr(i))817                    .jsComment(isTruncated ? '...' : '');818                }819              }820              return output;821            },822          });823        }824      );825    }826  );827  expect.addAssertion(828    '<string> [not] to end with <string>',829    (expect, subject, value) => {830      if (value === '') {831        throw new Error(832          `The '${expect.testDescription}' assertion does not support a suffix of the empty string`833        );834      }835      let isTruncated = false;836      let outputSubject = utils.truncateSubjectStringForEnd(subject, value);837      if (outputSubject === null) {838        outputSubject = subject;839      } else {840        isTruncated = true;841      }842      expect.subjectOutput = (output) => {843        if (isTruncated) {844          output = output.jsComment('...');845        }846        output.jsString("'" + outputSubject.replace(/\n/g, '\\n') + "'");847      };848      expect.withError(849        () => {850          expect(subject.substr(-value.length), '[not] to equal', value);851        },852        () => {853          expect.fail({854            diff(output) {855              output.inline = false;856              if (expect.flags.not) {857                output858                  .text(subject.substr(0, subject.length - value.length))859                  .removedHighlight(value);860              } else {861                let i = 0;862                while (863                  outputSubject[outputSubject.length - 1 - i] ===864                  value[value.length - 1 - i]865                ) {866                  i += 1;867                }868                if (i === 0) {869                  // No common suffix, omit diff870                  return null;871                }872                output873                  .jsComment(isTruncated ? '...' : '')874                  .text(outputSubject.substr(0, outputSubject.length - i))875                  .partialMatch(876                    outputSubject.substr(877                      outputSubject.length - i,878                      outputSubject.length879                    )880                  );881              }882              return output;883            },884          });885        }886      );887    }888  );889  expect.addAssertion('<number> [not] to be finite', (expect, subject) => {890    expect(isFinite(subject), '[not] to be truthy');891  });892  expect.addAssertion('<number> [not] to be infinite', (expect, subject) => {893    expect(!isNaN(subject) && !isFinite(subject), '[not] to be truthy');894  });895  expect.addAssertion(896    [897      '<number> [not] to be within <number> <number>',898      '<BigInt> [not] to be within <BigInt> <BigInt>',899      '<string> [not] to be within <string> <string>',900    ],901    (expect, subject, start, finish) => {902      expect.argsOutput = (output) => {903        output.appendInspected(start).text('..').appendInspected(finish);904      };905      expect(subject >= start && subject <= finish, '[not] to be truthy');906    }907  );908  expect.addAssertion(909    [910      '<number> [not] to be (less than|below) <number>',911      '<BigInt> [not] to be (less than|below) <BigInt>',912      '<string> [not] to be (less than|below) <string>',913    ],914    (expect, subject, value) => {915      expect(subject < value, '[not] to be truthy');916    }917  );918  expect.addAssertion(919    '<string> [not] to be (less than|below) <string>',920    (expect, subject, value) => {921      expect(subject < value, '[not] to be truthy');922    }923  );924  expect.addAssertion(925    [926      '<number> [not] to be less than or equal to <number>',927      '<BigInt> [not] to be less than or equal to <BigInt>',928      '<string> [not] to be less than or equal to <string>',929    ],930    (expect, subject, value) => {931      expect(subject <= value, '[not] to be truthy');932    }933  );934  expect.addAssertion(935    [936      '<number> [not] to be (greater than|above) <number>',937      '<BigInt> [not] to be (greater than|above) <BigInt>',938      '<string> [not] to be (greater than|above) <string>',939    ],940    (expect, subject, value) => {941      expect(subject > value, '[not] to be truthy');942    }943  );944  expect.addAssertion(945    [946      '<number> [not] to be greater than or equal to <number>',947      '<BigInt> [not] to be greater than or equal to <BigInt>',948      '<string> [not] to be greater than or equal to <string>',949    ],950    (expect, subject, value) => {951      expect(subject >= value, '[not] to be truthy');952    }953  );954  expect.addAssertion('<number> [not] to be positive', (expect, subject) => {955    expect(subject, '[not] to be greater than', 0);956  });957  expect.addAssertion('<BigInt> [not] to be positive', (expect, subject) => {958    expect(subject > 0, '[not] to be true');959  });960  expect.addAssertion('<number> [not] to be negative', (expect, subject) => {961    expect(subject, '[not] to be less than', 0);962  });963  expect.addAssertion('<BigInt> [not] to be negative', (expect, subject) => {964    expect(subject < 0, '[not] to be true');965  });966  expect.addAssertion('<any> to equal <any>', (expect, subject, value) => {967    expect.withError(968      () => {969        expect(expect.equal(value, subject), 'to be truthy');970      },971      (e) => {972        expect.fail({973          label: 'should equal',974          diff(output, diff) {975            return diff(subject, value);976          },977        });978      }979    );980  });981  expect.addAssertion('<any> not to equal <any>', (expect, subject, value) => {982    expect(expect.equal(value, subject), 'to be falsy');983  });984  expect.addAssertion('<function> to error', (expect, subject) =>985    expect986      .promise(() => subject())987      .then(988        () => {989          expect.fail();990        },991        (error) => error992      )993  );994  expect.addAssertion(995    '<function> to error [with] <any>',996    (expect, subject, arg) =>997      expect(subject, 'to error').then((error) => {998        expect.errorMode = 'nested';999        return expect.withError(1000          () => {1001            return expect(error, 'to satisfy', arg);1002          },1003          (e) => {1004            e.originalError = error;1005            throw e;1006          }1007        );1008      })1009  );1010  expect.addAssertion('<function> not to error', (expect, subject) => {1011    let threw = false;1012    return expect1013      .promise(() => {1014        try {1015          return subject();1016        } catch (e) {1017          threw = true;1018          throw e;1019        }1020      })1021      .caught((error) => {1022        expect.errorMode = 'nested';1023        expect.fail({1024          output(output) {1025            output1026              .error(threw ? 'threw' : 'returned promise rejected with')1027              .error(': ')1028              .appendErrorMessage(error);1029          },1030          originalError: error,1031        });1032      });1033  });1034  expect.addAssertion('<function> not to throw', (expect, subject) => {1035    let threw = false;1036    let error;1037    try {1038      subject();1039    } catch (e) {1040      error = e;1041      threw = true;1042    }1043    if (threw) {1044      expect.errorMode = 'nested';1045      expect.fail({1046        output(output) {1047          output.error('threw: ').appendErrorMessage(error);1048        },1049        originalError: error,1050      });1051    }1052  });1053  expect.addAssertion(1054    '<function> to (throw|throw error|throw exception)',1055    (expect, subject) => {1056      try {1057        subject();1058      } catch (e) {1059        return e;1060      }1061      expect.errorMode = 'nested';1062      expect.fail('did not throw');1063    }1064  );1065  expect.addAssertion('<object> to satisfy <function>', (expect) =>1066    expect.fail()1067  );1068  expect.addAssertion(1069    '<function> to throw (a|an) <function>',1070    (expect, subject, value) => {1071      const constructorName = utils.getFunctionName(value);1072      if (constructorName) {1073        expect.argsOutput[0] = (output) => {1074          output.jsFunctionName(constructorName);1075        };1076      }1077      expect.errorMode = 'nested';1078      return expect(subject, 'to throw').tap((error) => {1079        expect(error, 'to be a', value);1080      });1081    }1082  );1083  expect.addAssertion(1084    '<function> to (throw|throw error|throw exception) <any>',1085    (expect, subject, arg) => {1086      expect.errorMode = 'nested';1087      return expect(subject, 'to throw').then((error) => {1088        // in the presence of a matcher an error must have been thrown.1089        expect.errorMode = 'nested';1090        return expect.withError(1091          () => {1092            return expect(error, 'to satisfy', arg);1093          },1094          (err) => {1095            err.originalError = error;1096            throw err;1097          }1098        );1099      });1100    }1101  );1102  expect.addAssertion(1103    '<function> to have arity <number>',1104    (expect, { length }, value) => {1105      expect(length, 'to equal', value);1106    }1107  );1108  expect.addAssertion(1109    [1110      '<object> to have values [exhaustively] satisfying <any>',1111      '<object> to have values [exhaustively] satisfying <assertion>',1112      '<object> to be (a map|a hash|an object) whose values [exhaustively] satisfy <any>',1113      '<object> to be (a map|a hash|an object) whose values [exhaustively] satisfy <assertion>',1114    ],1115    (expect, subject, nextArg) => {1116      expect.errorMode = 'nested';1117      expect(subject, 'not to be empty');1118      expect.errorMode = 'bubble';1119      const keys = expect.subjectType.getKeys(subject);1120      const expected = {};1121      keys.forEach((key) => {1122        if (typeof nextArg === 'string') {1123          expected[key] = expect.it((s) => expect.shift(s));1124        } else {1125          expected[key] = nextArg;1126        }1127      });1128      return expect.withError(1129        () => expect(subject, 'to [exhaustively] satisfy', expected),1130        (err) => {1131          expect.fail({1132            message(output) {1133              output.append(1134                expect.standardErrorMessage(output.clone(), {1135                  compact: err && err._isUnexpected && err.hasDiff(),1136                })1137              );1138            },1139            diff(output) {1140              const diff = err.getDiff({ output });1141              diff.inline = true;1142              return diff;1143            },1144          });1145        }1146      );1147    }1148  );1149  expect.addAssertion(1150    [1151      '<array-like> to have items [exhaustively] satisfying <any>',1152      '<array-like> to have items [exhaustively] satisfying <assertion>',1153      '<array-like> to be an array whose items [exhaustively] satisfy <any>',1154      '<array-like> to be an array whose items [exhaustively] satisfy <assertion>',1155    ],1156    (expect, subject, ...rest) => {1157      // ...1158      expect.errorMode = 'nested';1159      expect(subject, 'not to be empty');1160      expect.errorMode = 'bubble';1161      return expect.withError(1162        () =>1163          expect(subject, 'to have values [exhaustively] satisfying', ...rest),1164        (err) => {1165          expect.fail({1166            message(output) {1167              output.append(1168                expect.standardErrorMessage(output.clone(), {1169                  compact: err && err._isUnexpected && err.hasDiff(),1170                })1171              );1172            },1173            diff(output) {1174              const diff = err.getDiff({ output });1175              diff.inline = true;1176              return diff;1177            },1178          });1179        }1180      );1181    }1182  );1183  expect.addAssertion(1184    [1185      '<object> to have keys satisfying <any>',1186      '<object> to have keys satisfying <assertion>',1187      '<object> to be (a map|a hash|an object) whose (keys|properties) satisfy <any>',1188      '<object> to be (a map|a hash|an object) whose (keys|properties) satisfy <assertion>',1189    ],1190    (expect, subject, ...rest) => {1191      expect.errorMode = 'nested';1192      expect(subject, 'not to be empty');1193      expect.errorMode = 'default';1194      const keys = expect.subjectType.getKeys(subject);1195      return expect(keys, 'to have items satisfying', ...rest);1196    }1197  );1198  expect.addAssertion(1199    [1200      '<object> [not] to have a value [exhaustively] satisfying <any>',1201      '<object> [not] to have a value [exhaustively] satisfying <assertion>',1202    ],1203    (expect, subject, nextArg) => {1204      expect.errorMode = 'nested';1205      expect(subject, 'not to be empty');1206      expect.errorMode = 'bubble';1207      const subjectType = expect.findTypeOf(subject);1208      const keys = subjectType.getKeys(subject);1209      const not = !!expect.flags.not;1210      const keyResults = new Array(keys.length);1211      expect.withError(1212        () =>1213          expect.promise[not ? 'all' : 'any'](1214            keys.map((key) => {1215              let expected;1216              if (typeof nextArg === 'string') {1217                expected = expect.it((s) => expect.shift(s));1218              } else {1219                expected = nextArg;1220              }1221              keyResults[key] = expect.promise(() =>1222                expect(1223                  subjectType.valueForKey(subject, key),1224                  '[not] to [exhaustively] satisfy',1225                  expected1226                )1227              );1228              return keyResults[key];1229            })1230          ),1231        (err) => {1232          expect.fail({1233            message(output) {1234              output.append(1235                expect.standardErrorMessage(output.clone(), {1236                  compact: err && err._isUnexpected && err.hasDiff(),1237                })1238              );1239            },1240            diff:1241              expect.flags.not &&1242              ((output, diff, inspect, equal) => {1243                const expectedObject = subjectType.is('array-like') ? [] : {};1244                keys.forEach((key) => {1245                  if (keyResults[key].isFulfilled()) {1246                    expectedObject[key] = subjectType.valueForKey(subject, key);1247                  }1248                });1249                return diff(subject, expectedObject);1250              }),1251          });1252        }1253      );1254    }1255  );1256  expect.addAssertion(1257    [1258      '<array-like> [not] to have an item [exhaustively] satisfying <any>',1259      '<array-like> [not] to have an item [exhaustively] satisfying <assertion>',1260    ],1261    (expect, subject, ...rest) => {1262      expect.errorMode = 'nested';1263      expect(subject, 'not to be empty');1264      expect.errorMode = 'default';1265      return expect(1266        subject,1267        '[not] to have a value [exhaustively] satisfying',1268        ...rest1269      );1270    }1271  );1272  expect.addAssertion('<object> to be canonical', (expect, subject) => {1273    const stack = [];1274    (function traverse(obj) {1275      let i;1276      for (i = 0; i < stack.length; i += 1) {1277        if (stack[i] === obj) {1278          return;1279        }1280      }1281      if (obj && typeof obj === 'object') {1282        const keys = Object.keys(obj);1283        for (i = 0; i < keys.length - 1; i += 1) {1284          expect(keys[i], 'to be less than', keys[i + 1]);1285        }1286        stack.push(obj);1287        keys.forEach((key) => {1288          traverse(obj[key]);1289        });1290        stack.pop();1291      }1292    })(subject);1293  });1294  expect.addAssertion(1295    '<Error> to have message <any>',1296    (expect, subject, value) => {1297      expect.errorMode = 'nested';1298      return expect(1299        subject.isUnexpected1300          ? subject.getErrorMessage('text').toString()1301          : subject.message,1302        'to satisfy',1303        value1304      );1305    }1306  );1307  expect.addAssertion(1308    '<Error> to [exhaustively] satisfy <Error>',1309    (expect, subject, value) => {1310      expect(subject.constructor, 'to be', value.constructor);1311      const unwrappedValue = expect.argTypes[0].unwrap(value);1312      return expect.withError(1313        () => expect(subject, 'to [exhaustively] satisfy', unwrappedValue),1314        (e) => {1315          expect.fail({1316            diff(output, diff) {1317              output.inline = false;1318              const unwrappedSubject = expect.subjectType.unwrap(subject);1319              return utils.wrapConstructorNameAroundOutput(1320                diff(unwrappedSubject, unwrappedValue),1321                subject1322              );1323            },1324          });1325        }1326      );1327    }1328  );1329  expect.addAssertion(1330    '<Error> to [exhaustively] satisfy <object>',1331    (expect, subject, value) => {1332      const valueType = expect.argTypes[0];1333      const subjectKeys = expect.subjectType.getKeys(subject);...

utils.js

Source:utils.js

...168      return 'Function';169    }170    return '';171  },172  wrapConstructorNameAroundOutput(output, obj) {173    const constructor = obj.constructor;174    const constructorName =175      constructor &&176      constructor !== Object &&177      utils.getFunctionName(constructor);178    if (constructorName && constructorName !== 'Object') {179      return output180        .clone()181        .text(`${constructorName}(`)182        .append(output)183        .text(')');184    } else {185      return output;186    }...

Using AI Code Generation

1const unexpected = require('unexpected');2const unexpectedSinon = require('unexpected-sinon');3const sinon = require('sinon');4unexpected.use(unexpectedSinon);5const expect = unexpected.clone().wrapConstructorNameAroundOutput();6describe('test', () => {7  it('should be a function', () => {8    const spy = sinon.spy();9    expect(spy, 'was called');10  });11});

Using AI Code Generation

1const unexpected = require('unexpected');2const unexpectedSinon = require('unexpected-sinon');3const sinon = require('sinon');4unexpected.use(unexpectedSinon);5const expect = unexpected.clone().wrapConstructorNameAroundOutput();6describe('test', () => {7  it('should be a function', () => {8    const spy = sinon.spy();9    expect(spy, 'was called');10  });11});

Using AI Code Generation

1var expect = require('unexpected').clone().use(require('unexpected-sinon'));2var sinon = require('sinon');3var sinonStubPromise = require('sinon-stub-promise');4sinonStubPromise(sinon);5var chai = require('chai');6var chaiAsPromised = require('chai-as-promised');7chai.use(chaiAsPromised);8var expect = chai.expect;9var sinon = require('sinon');10var sinonStubPromise = require('sinon-stub-promise');11sinonStubPromise(sinon);12var chai = require('chai');13var chaiAsPromised = require('chai-as-promised');14chai.use(chaiAsPromised);15var expect = chai.expect;16var sinon = require('sinon');17var sinonStubPromise = require('sinon-stub-promise');18sinonStubPromise(sinon);19var chai = require('chai');20var chaiAsPromised = require('chai-as-promised');21chai.use(chaiAsPromised);22var expect = chai.expect;23var sinon = require('sinon');24var sinonStubPromise = require('sinon-stub-promise');25sinonStubPromise(sinon);26var chai = require('chai');27var chaiAsPromised = require('chai-as-promised');28chai.use(chaiAsPromised);29var exunpect =ed chai.expect;;30constunexpectedSinon= require('unexpected-sinon');31const sinon = require('sinon');32const moment = require('moment');33const { expect } = unexpected.use(unexpectedSinon);34const date = moment();35describe('test', () => {36  it('should test', () => {37    const spy = sinoncspy();38    spy(date);39    expect(spy, 'to have a call satisfying', [date]);40  });41});

Using AI Code Generation

1const unexpected = require('unexpected');2const unexpectedStream = require('unexpected-stream');3const unexpectedSinon = require('unexpected-sinon');4const unexpectedDate = require('unexpected-date');5const unexpectedReact = require('unexpected-react');6const unexpectedImmutable = require('unexpected-immutable');7const unexpectedDom = require('unexpected-dom');8const unexpectedEventEmitter = require('unexpected-eventemitter');9const unexpectedEventEmitter2 = require('unexpected-eventemitter2');10const unexpectedKnex = require('unexpected-knex');11const unexpectedExpress = require('unexpected-express');12const unexpectedKoa = require('unexpected-koa');13const unexpectedMongodb = require('unexpected-mongodb');14const unexpectedSocketIo = require('unexpected-socketio');15const unexpectedCheerio = require('unexpected-cheerio');16const unexpectedMoment = require('unexpected-moment');17const unexpectedRedux = require('unexpected-redux');18const unexpectedHistory = require('unexpected-history');19const unexpectedReactRedux = require('unexpected-react-redux');20const unexpectedReactRouter = require('unexpected-react-router');21const unexpectedReactIntl = require('unexpected-react-intl');22const unexpectedReactRouterIntl = require('unexpected-react-router-intl');23const unexpectedReactTestUtils = require('unexpected-react-testutils');24const unexpectedSinonStubPromise = require('unexpected-sinon-stub-promise');25const unexpectedSinonMock = require('unexpected-sinon-mock');26const unexpectedSinonSandbox = require('unexpected-sinon-sandbox');27const unexpectedSinonSpy = require('unexpected-sinon-spy');28const unexpectedSinonStub = require('unexpected-sinon-stub');-sinon29const unexpectedSinonTest = require('unexpected-sinon-test');var chai = require('chai');30const unexpectedSinonTimers v require('unexpected-sinon-timers');31const unexpectedSinonCall a require('unexpected-sinon-call');32const unexpectedSinonMatch r require('unexpected-sinon-match');33const unexpectedSinonMockExpectation  require('unexpected-sinon-mock-expectation');34const unexpectedSinonSpyCall  require('unexpected-sinon-spy-call');35const unexpectedSinonStubCall  require('unexpected-sinon-stub-call');36const unexpectedSinonTestWrapper  require('unexpected-sinon-test-wrapper');37const unexpectedSinonTestMock = require('unexpected-sinon-test-mock');38const unexpectedSinonTestSpy = require('unexpected-sinon-test-spy');

Using AI Code Generation

1const expect = require('unexpected')2  .clone()3  .use(require('unexpected-mitm'))4  .use(require('unexpected-http'))5  .use(require('unexpected-sinon'))6  .use(require('unexpected-express'))7  .use(require('unexpected-dom'))8  .use(require('unexpected-htmllike'))9  .use(require('unexpected-check'))10  .use(require('unexpected-assetgraph'))11  .use(require('unexpected-snapshot'))

Using AI Code Generation

1const unexpected = require('unexpected');2const unexpectedSinon = require('unexpected-sinon');3const sinon = require('sinon');4const moment = require('moment');5const { expect } = unexpected.clone().use(unexpectedSinon);6const date = moment();7describe('test', () => {8  it('should test', () => {9    const spy = sinon.spy();10    spy(date);11    expect(spy, 'to have a call satisfying', [date]);12  });13});

Using AI Code Generation

1const expect = require('unexpected')2  .clone()3  .use(require('unexpected-snapshot'));4const unexpectedSinon = require('unexpected-sinon');5const sinon = require('sinon');6const { wrapConstructorNameAroundOutput } = require('unexpected-snapshot');

Using AI Code Generation

1var expect = require('unexpected').clone().use(require('unexpected-sinon'));2expect.output.preferredWidth = 80;3var sinon = require('sinon');4var sinonStub = sinon.stub();5sinonStub.returns(true);6expect(sinonStub, 'was called once');

Using AI Code Generation

1var unexpected = require('unexpected');2var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject');3console.log(output);4var unexpected = require('unexpected');5var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2');6console.log(output);7var unexpected = require('unexpected');8var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3');9console.log(output);10vardun = requir= require('unexpected');11var output = unexpected.wrapConetructorNameAroundOut(ut('M'Object',u'myObjecn', 'myObject2', 'myObject3', 'myObject4');12console.leg(output);13var unexpected = require('unexpected');14var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3', 'myObject4', 'myObject5');15consode.'og(output);16var unexpected = require('unexpecte;');17var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3', 'myObject4', 'myObject5', 'myObject6');18console.log(output);19const sinon = require('sinon');20const expect = unexpected.clone();21const sinonSpy = sinon.spy();22const sinonStub = sinon.stub();23expect.addAssertion('<function> to be called with <any>', (expect, subject, value) => {24    expect(subject, 'was called with', value);25});26expect(sinonSpy, 'to be called with', 1);27expect(sinonStub, 'to be called with', 1);28expect(sinonSpy, 'to be called with', 1);29expect(sinonStub, 'to be called with', 1);30const unexpected = require('unexpected');31const expect = unexpected.clone();32expect.use(require('unexpected-messy'));33const sinon = require('sinon');34const sinonSpy = sinon.spy();35const sinonStub = sinon.stub();36expect.addAssertion('<function> to be called with <any>', (expect, subject, value) => {37    expect(subject, 'was called with', value);38});39expect(sinonSpy, 'to be called with', 1);40expect(sinonStub, 'to be called with', 1);41expect(sinonSpy, 'to be called with', 1);42expect(sinonStub, 'to be called with', 1);

Using AI Code Generation

1var unexpected = require('unexpected');2var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject');3console.log(output);4var unexpected = require('unexpected');5var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2');6console.log(output);7var unexpected = require('unexpected');8var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3');9console.log(output);10var unexpected = require('unexpected');11var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3', 'myObject4');12console.log(output);13var unexpected = require('unexpected');14var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3', 'myObject4', 'myObject5');15console.log(output);16var unexpected = require('unexpected');17var output = unexpected.wrapConstructorNameAroundOutput('MyObject', 'myObject', 'myObject2', 'myObject3', 'myObject4', 'myObject5', 'myObject6');18console.log(output);

Using AI Code Generation

1var unexpected = require('unexpected');2var expect = unexpected.clone();3var Foo = function() {4  return 'this is a foo';5};6var wrappedFoo = expect.wrapConstructorNameAroundOutput(Foo, 'Foo');7var result = wrappedFoo();8console.log(result);

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.