@itentialopensource/adapter-amazon_route53 0.1.1 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (38) hide show
  1. package/AUTH.md +79 -0
  2. package/BROKER.md +199 -0
  3. package/CALLS.md +169 -0
  4. package/CHANGELOG.md +9 -2
  5. package/CODE_OF_CONDUCT.md +12 -17
  6. package/CONTRIBUTING.md +88 -74
  7. package/ENHANCE.md +69 -0
  8. package/PROPERTIES.md +641 -0
  9. package/README.md +221 -571
  10. package/SUMMARY.md +9 -0
  11. package/SYSTEMINFO.md +11 -0
  12. package/TROUBLESHOOT.md +47 -0
  13. package/adapter.js +4005 -2171
  14. package/adapterBase.js +1006 -252
  15. package/entities/.generic/action.json +105 -0
  16. package/entities/.generic/schema.json +6 -1
  17. package/entities/{20130401 → Rest}/action.json +64 -64
  18. package/entities/{20130401 → Rest}/schema.json +0 -0
  19. package/error.json +6 -0
  20. package/package.json +7 -3
  21. package/pronghorn.json +5185 -967
  22. package/propertiesDecorators.json +14 -0
  23. package/propertiesSchema.json +437 -0
  24. package/refs?service=git-upload-pack +0 -0
  25. package/report/adapterInfo.json +10 -0
  26. package/report/updateReport1652046310866.json +119 -0
  27. package/report/updateReport1652623514577.json +120 -0
  28. package/sampleProperties.json +91 -1
  29. package/test/integration/adapterTestBasicGet.js +1 -1
  30. package/test/integration/adapterTestIntegration.js +1314 -1789
  31. package/test/unit/adapterBaseTestUnit.js +30 -25
  32. package/test/unit/adapterTestUnit.js +167 -254
  33. package/utils/adapterInfo.js +206 -0
  34. package/utils/entitiesToDB.js +12 -57
  35. package/utils/pre-commit.sh +3 -0
  36. package/utils/tbScript.js +35 -20
  37. package/utils/tbUtils.js +49 -31
  38. package/utils/testRunner.js +16 -16
package/test/integration/adapterTestIntegration.js CHANGED
@@ -3,6 +3,8 @@
3
3
  // Set globals
4
4
  /* global describe it log pronghornProps */
5
5
  /* eslint no-unused-vars: warn */
6
+ /* eslint no-underscore-dangle: warn */
7
+ /* eslint import/no-dynamic-require:warn */
6
8
 
7
9
  // include required items for testing & logging
8
10
  const assert = require('assert');
@@ -14,27 +16,38 @@ const { expect } = require('chai');
14
16
  const { use } = require('chai');
15
17
  const td = require('testdouble');
16
18
  const util = require('util');
17
- const pronghorn = require('../../pronghorn.json');
18
19
 
19
- pronghorn.methodsByName = pronghorn.methods.reduce((result, meth) => ({ ...result, [meth.name]: meth }), {});
20
20
  const anything = td.matchers.anything();
21
21
 
22
22
  // stub and attemptTimeout are used throughout the code so set them here
23
23
  let logLevel = 'none';
24
- const stub = true;
25
24
  const isRapidFail = false;
26
25
  const isSaveMockData = false;
27
- const attemptTimeout = 5000;
26
+
27
+ // read in the properties from the sampleProperties files
28
+ let adaptdir = __dirname;
29
+ if (adaptdir.endsWith('/test/integration')) {
30
+ adaptdir = adaptdir.substring(0, adaptdir.length - 17);
31
+ } else if (adaptdir.endsWith('/test/unit')) {
32
+ adaptdir = adaptdir.substring(0, adaptdir.length - 10);
33
+ }
34
+ const samProps = require(`${adaptdir}/sampleProperties.json`).properties;
28
35
 
29
36
  // these variables can be changed to run in integrated mode so easier to set them here
30
37
  // always check these in with bogus data!!!
31
- const host = 'replace.hostorip.here';
32
- const username = 'username';
33
- const password = 'password';
34
- const protocol = 'http';
35
- const port = 80;
36
- const sslenable = false;
37
- const sslinvalid = false;
38
+ samProps.stub = true;
39
+ samProps.host = 'replace.hostorip.here';
40
+ samProps.authentication.username = 'username';
41
+ samProps.authentication.password = 'password';
42
+ samProps.protocol = 'http';
43
+ samProps.port = 80;
44
+ samProps.ssl.enabled = false;
45
+ samProps.ssl.accept_invalid_cert = false;
46
+ if (samProps.request.attempt_timeout < 30000) {
47
+ samProps.request.attempt_timeout = 30000;
48
+ }
49
+ const attemptTimeout = samProps.request.attempt_timeout;
50
+ const { stub } = samProps;
38
51
 
39
52
  // these are the adapter properties. You generally should not need to alter
40
53
  // any of these after they are initially set up
@@ -46,102 +59,7 @@ global.pronghornProps = {
46
59
  adapters: [{
47
60
  id: 'Test-amazon_route53',
48
61
  type: 'AmazonRoute53',
49
- properties: {
50
- host,
51
- port,
52
- base_path: '/',
53
- version: '',
54
- cache_location: 'none',
55
- encode_pathvars: true,
56
- save_metric: false,
57
- stub,
58
- protocol,
59
- authentication: {
60
- auth_method: 'no_authentication',
61
- username,
62
- password,
63
- token: '',
64
- invalid_token_error: 401,
65
- token_timeout: -1,
66
- token_cache: 'local',
67
- auth_field: 'header.headers.Authorization',
68
- auth_field_format: 'Basic {b64}{username}:{password}{/b64}',
69
- auth_logging: false,
70
- client_id: '',
71
- client_secret: '',
72
- grant_type: ''
73
- },
74
- healthcheck: {
75
- type: 'none',
76
- frequency: 60000,
77
- query_object: {}
78
- },
79
- throttle: {
80
- throttle_enabled: false,
81
- number_pronghorns: 1,
82
- sync_async: 'sync',
83
- max_in_queue: 1000,
84
- concurrent_max: 1,
85
- expire_timeout: 0,
86
- avg_runtime: 200,
87
- priorities: [
88
- {
89
- value: 0,
90
- percent: 100
91
- }
92
- ]
93
- },
94
- request: {
95
- number_redirects: 0,
96
- number_retries: 3,
97
- limit_retry_error: [0],
98
- failover_codes: [],
99
- attempt_timeout: attemptTimeout,
100
- global_request: {
101
- payload: {},
102
- uriOptions: {},
103
- addlHeaders: {},
104
- authData: {}
105
- },
106
- healthcheck_on_timeout: true,
107
- return_raw: true,
108
- archiving: false,
109
- return_request: false
110
- },
111
- proxy: {
112
- enabled: false,
113
- host: '',
114
- port: 1,
115
- protocol: 'http',
116
- username: '',
117
- password: ''
118
- },
119
- ssl: {
120
- ecdhCurve: '',
121
- enabled: sslenable,
122
- accept_invalid_cert: sslinvalid,
123
- ca_file: '',
124
- key_file: '',
125
- cert_file: '',
126
- secure_protocol: '',
127
- ciphers: ''
128
- },
129
- mongo: {
130
- host: '',
131
- port: 0,
132
- database: '',
133
- username: '',
134
- password: '',
135
- replSet: '',
136
- db_ssl: {
137
- enabled: false,
138
- accept_invalid_cert: false,
139
- ca_file: '',
140
- key_file: '',
141
- cert_file: ''
142
- }
143
- }
144
- }
62
+ properties: samProps
145
63
  }]
146
64
  }
147
65
  };
@@ -425,69 +343,55 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
425
343
  -----------------------------------------------------------------------
426
344
  -----------------------------------------------------------------------
427
345
  */
428
- let skipCount = 0;
429
-
430
346
  const CreateReusableDelegationSetBodyParam = '<xml>fakedata</xml>';
431
347
  describe('#createReusableDelegationSet - errors', () => {
432
348
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
433
- if (pronghorn.methodsByName.createReusableDelegationSet.task) {
434
- try {
435
- a.createReusableDelegationSet(CreateReusableDelegationSetBodyParam, (data, error) => {
436
- try {
437
- if (stub) {
438
- const displayE = 'Error 400 received on request';
439
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
440
- } else {
441
- runCommonAsserts(data, error);
442
- }
443
- saveMockData('20130401', 'createReusableDelegationSet', 'default', data);
444
- done();
445
- } catch (err) {
446
- log.error(`Test Failure: ${err}`);
447
- done(err);
448
- }
449
- });
450
- } catch (error) {
451
- log.error(`Adapter Exception: ${error}`);
452
- done(error);
453
- }
454
- } else {
455
- log.error('createReusableDelegationSet task is false, skipping test');
456
- skipCount += 1;
457
- done();
458
- }// end if task
349
+ try {
350
+ a.createReusableDelegationSet(CreateReusableDelegationSetBodyParam, (data, error) => {
351
+ try {
352
+ if (stub) {
353
+ const displayE = 'Error 400 received on request';
354
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
355
+ } else {
356
+ runCommonAsserts(data, error);
357
+ }
358
+ saveMockData('20130401', 'createReusableDelegationSet', 'default', data);
359
+ done();
360
+ } catch (err) {
361
+ log.error(`Test Failure: ${err}`);
362
+ done(err);
363
+ }
364
+ });
365
+ } catch (error) {
366
+ log.error(`Adapter Exception: ${error}`);
367
+ done(error);
368
+ }
459
369
  }).timeout(attemptTimeout);
460
370
  });
461
371
 
462
372
  const CreateHealthCheckBodyParam = '<xml>fakedata</xml>';
463
373
  describe('#createHealthCheck - errors', () => {
464
374
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
465
- if (pronghorn.methodsByName.createHealthCheck.task) {
466
- try {
467
- a.createHealthCheck(CreateHealthCheckBodyParam, (data, error) => {
468
- try {
469
- if (stub) {
470
- const displayE = 'Error 400 received on request';
471
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
472
- } else {
473
- runCommonAsserts(data, error);
474
- }
475
- saveMockData('20130401', 'createHealthCheck', 'default', data);
476
- done();
477
- } catch (err) {
478
- log.error(`Test Failure: ${err}`);
479
- done(err);
480
- }
481
- });
482
- } catch (error) {
483
- log.error(`Adapter Exception: ${error}`);
484
- done(error);
485
- }
486
- } else {
487
- log.error('createHealthCheck task is false, skipping test');
488
- skipCount += 1;
489
- done();
490
- }// end if task
375
+ try {
376
+ a.createHealthCheck(CreateHealthCheckBodyParam, (data, error) => {
377
+ try {
378
+ if (stub) {
379
+ const displayE = 'Error 400 received on request';
380
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
381
+ } else {
382
+ runCommonAsserts(data, error);
383
+ }
384
+ saveMockData('20130401', 'createHealthCheck', 'default', data);
385
+ done();
386
+ } catch (err) {
387
+ log.error(`Test Failure: ${err}`);
388
+ done(err);
389
+ }
390
+ });
391
+ } catch (error) {
392
+ log.error(`Adapter Exception: ${error}`);
393
+ done(error);
394
+ }
491
395
  }).timeout(attemptTimeout);
492
396
  });
493
397
 
@@ -495,64 +399,52 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
495
399
  const UpdateHealthCheckBodyParam = '<xml>fakedata</xml>';
496
400
  describe('#updateHealthCheck - errors', () => {
497
401
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
498
- if (pronghorn.methodsByName.updateHealthCheck.task) {
499
- try {
500
- a.updateHealthCheck(HealthCheckId, UpdateHealthCheckBodyParam, (data, error) => {
501
- try {
502
- if (stub) {
503
- const displayE = 'Error 400 received on request';
504
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
505
- } else {
506
- runCommonAsserts(data, error);
507
- }
508
- saveMockData('20130401', 'updateHealthCheck', 'default', data);
509
- done();
510
- } catch (err) {
511
- log.error(`Test Failure: ${err}`);
512
- done(err);
513
- }
514
- });
515
- } catch (error) {
516
- log.error(`Adapter Exception: ${error}`);
517
- done(error);
518
- }
519
- } else {
520
- log.error('updateHealthCheck task is false, skipping test');
521
- skipCount += 1;
522
- done();
523
- }// end if task
402
+ try {
403
+ a.updateHealthCheck(HealthCheckId, UpdateHealthCheckBodyParam, (data, error) => {
404
+ try {
405
+ if (stub) {
406
+ const displayE = 'Error 400 received on request';
407
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
408
+ } else {
409
+ runCommonAsserts(data, error);
410
+ }
411
+ saveMockData('20130401', 'updateHealthCheck', 'default', data);
412
+ done();
413
+ } catch (err) {
414
+ log.error(`Test Failure: ${err}`);
415
+ done(err);
416
+ }
417
+ });
418
+ } catch (error) {
419
+ log.error(`Adapter Exception: ${error}`);
420
+ done(error);
421
+ }
524
422
  }).timeout(attemptTimeout);
525
423
  });
526
424
 
527
425
  const CreateHostedZoneBodyParam = '<xml>fakedata</xml>';
528
426
  describe('#createHostedZone - errors', () => {
529
427
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
530
- if (pronghorn.methodsByName.createHostedZone.task) {
531
- try {
532
- a.createHostedZone(CreateHostedZoneBodyParam, (data, error) => {
533
- try {
534
- if (stub) {
535
- const displayE = 'Error 400 received on request';
536
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
537
- } else {
538
- runCommonAsserts(data, error);
539
- }
540
- saveMockData('20130401', 'createHostedZone', 'default', data);
541
- done();
542
- } catch (err) {
543
- log.error(`Test Failure: ${err}`);
544
- done(err);
545
- }
546
- });
547
- } catch (error) {
548
- log.error(`Adapter Exception: ${error}`);
549
- done(error);
550
- }
551
- } else {
552
- log.error('createHostedZone task is false, skipping test');
553
- skipCount += 1;
554
- done();
555
- }// end if task
428
+ try {
429
+ a.createHostedZone(CreateHostedZoneBodyParam, (data, error) => {
430
+ try {
431
+ if (stub) {
432
+ const displayE = 'Error 400 received on request';
433
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
434
+ } else {
435
+ runCommonAsserts(data, error);
436
+ }
437
+ saveMockData('20130401', 'createHostedZone', 'default', data);
438
+ done();
439
+ } catch (err) {
440
+ log.error(`Test Failure: ${err}`);
441
+ done(err);
442
+ }
443
+ });
444
+ } catch (error) {
445
+ log.error(`Adapter Exception: ${error}`);
446
+ done(error);
447
+ }
556
448
  }).timeout(attemptTimeout);
557
449
  });
558
450
 
@@ -560,286 +452,232 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
560
452
  const UpdateHostedZoneCommentBodyParam = '<xml>fakedata</xml>';
561
453
  describe('#updateHostedZoneComment - errors', () => {
562
454
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
563
- if (pronghorn.methodsByName.updateHostedZoneComment.task) {
564
- try {
565
- a.updateHostedZoneComment(Id, UpdateHostedZoneCommentBodyParam, (data, error) => {
566
- try {
567
- if (stub) {
568
- const displayE = 'Error 400 received on request';
569
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
570
- } else {
571
- runCommonAsserts(data, error);
572
- }
573
- saveMockData('20130401', 'updateHostedZoneComment', 'default', data);
574
- done();
575
- } catch (err) {
576
- log.error(`Test Failure: ${err}`);
577
- done(err);
578
- }
579
- });
580
- } catch (error) {
581
- log.error(`Adapter Exception: ${error}`);
582
- done(error);
583
- }
584
- } else {
585
- log.error('updateHostedZoneComment task is false, skipping test');
586
- skipCount += 1;
587
- done();
588
- }// end if task
455
+ try {
456
+ a.updateHostedZoneComment(Id, UpdateHostedZoneCommentBodyParam, (data, error) => {
457
+ try {
458
+ if (stub) {
459
+ const displayE = 'Error 400 received on request';
460
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
461
+ } else {
462
+ runCommonAsserts(data, error);
463
+ }
464
+ saveMockData('20130401', 'updateHostedZoneComment', 'default', data);
465
+ done();
466
+ } catch (err) {
467
+ log.error(`Test Failure: ${err}`);
468
+ done(err);
469
+ }
470
+ });
471
+ } catch (error) {
472
+ log.error(`Adapter Exception: ${error}`);
473
+ done(error);
474
+ }
589
475
  }).timeout(attemptTimeout);
590
476
  });
591
477
 
592
478
  const AssociateVPCWithHostedZoneBodyParam = '<xml>fakedata</xml>';
593
479
  describe('#associateVPCWithHostedZone - errors', () => {
594
480
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
595
- if (pronghorn.methodsByName.associateVPCWithHostedZone.task) {
596
- try {
597
- a.associateVPCWithHostedZone(Id, AssociateVPCWithHostedZoneBodyParam, (data, error) => {
598
- try {
599
- if (stub) {
600
- const displayE = 'Error 400 received on request';
601
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
602
- } else {
603
- runCommonAsserts(data, error);
604
- }
605
- saveMockData('20130401', 'associateVPCWithHostedZone', 'default', data);
606
- done();
607
- } catch (err) {
608
- log.error(`Test Failure: ${err}`);
609
- done(err);
610
- }
611
- });
612
- } catch (error) {
613
- log.error(`Adapter Exception: ${error}`);
614
- done(error);
615
- }
616
- } else {
617
- log.error('associateVPCWithHostedZone task is false, skipping test');
618
- skipCount += 1;
619
- done();
620
- }// end if task
481
+ try {
482
+ a.associateVPCWithHostedZone(Id, AssociateVPCWithHostedZoneBodyParam, (data, error) => {
483
+ try {
484
+ if (stub) {
485
+ const displayE = 'Error 400 received on request';
486
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
487
+ } else {
488
+ runCommonAsserts(data, error);
489
+ }
490
+ saveMockData('20130401', 'associateVPCWithHostedZone', 'default', data);
491
+ done();
492
+ } catch (err) {
493
+ log.error(`Test Failure: ${err}`);
494
+ done(err);
495
+ }
496
+ });
497
+ } catch (error) {
498
+ log.error(`Adapter Exception: ${error}`);
499
+ done(error);
500
+ }
621
501
  }).timeout(attemptTimeout);
622
502
  });
623
503
 
624
504
  const CreateVPCAssociationAuthorizationBodyParam = '<xml>fakedata</xml>';
625
505
  describe('#createVPCAssociationAuthorization - errors', () => {
626
506
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
627
- if (pronghorn.methodsByName.createVPCAssociationAuthorization.task) {
628
- try {
629
- a.createVPCAssociationAuthorization(Id, CreateVPCAssociationAuthorizationBodyParam, (data, error) => {
630
- try {
631
- if (stub) {
632
- const displayE = 'Error 400 received on request';
633
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
634
- } else {
635
- runCommonAsserts(data, error);
636
- }
637
- saveMockData('20130401', 'createVPCAssociationAuthorization', 'default', data);
638
- done();
639
- } catch (err) {
640
- log.error(`Test Failure: ${err}`);
641
- done(err);
642
- }
643
- });
644
- } catch (error) {
645
- log.error(`Adapter Exception: ${error}`);
646
- done(error);
647
- }
648
- } else {
649
- log.error('createVPCAssociationAuthorization task is false, skipping test');
650
- skipCount += 1;
651
- done();
652
- }// end if task
507
+ try {
508
+ a.createVPCAssociationAuthorization(Id, CreateVPCAssociationAuthorizationBodyParam, (data, error) => {
509
+ try {
510
+ if (stub) {
511
+ const displayE = 'Error 400 received on request';
512
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
513
+ } else {
514
+ runCommonAsserts(data, error);
515
+ }
516
+ saveMockData('20130401', 'createVPCAssociationAuthorization', 'default', data);
517
+ done();
518
+ } catch (err) {
519
+ log.error(`Test Failure: ${err}`);
520
+ done(err);
521
+ }
522
+ });
523
+ } catch (error) {
524
+ log.error(`Adapter Exception: ${error}`);
525
+ done(error);
526
+ }
653
527
  }).timeout(attemptTimeout);
654
528
  });
655
529
 
656
530
  const DeleteVPCAssociationAuthorizationBodyParam = '<xml>fakedata</xml>';
657
531
  describe('#deleteVPCAssociationAuthorization - errors', () => {
658
532
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
659
- if (pronghorn.methodsByName.deleteVPCAssociationAuthorization.task) {
660
- try {
661
- a.deleteVPCAssociationAuthorization(Id, DeleteVPCAssociationAuthorizationBodyParam, (data, error) => {
662
- try {
663
- if (stub) {
664
- const displayE = 'Error 400 received on request';
665
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
666
- } else {
667
- runCommonAsserts(data, error);
668
- }
669
- saveMockData('20130401', 'deleteVPCAssociationAuthorization', 'default', data);
670
- done();
671
- } catch (err) {
672
- log.error(`Test Failure: ${err}`);
673
- done(err);
674
- }
675
- });
676
- } catch (error) {
677
- log.error(`Adapter Exception: ${error}`);
678
- done(error);
679
- }
680
- } else {
681
- log.error('deleteVPCAssociationAuthorization task is false, skipping test');
682
- skipCount += 1;
683
- done();
684
- }// end if task
533
+ try {
534
+ a.deleteVPCAssociationAuthorization(Id, DeleteVPCAssociationAuthorizationBodyParam, (data, error) => {
535
+ try {
536
+ if (stub) {
537
+ const displayE = 'Error 400 received on request';
538
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
539
+ } else {
540
+ runCommonAsserts(data, error);
541
+ }
542
+ saveMockData('20130401', 'deleteVPCAssociationAuthorization', 'default', data);
543
+ done();
544
+ } catch (err) {
545
+ log.error(`Test Failure: ${err}`);
546
+ done(err);
547
+ }
548
+ });
549
+ } catch (error) {
550
+ log.error(`Adapter Exception: ${error}`);
551
+ done(error);
552
+ }
685
553
  }).timeout(attemptTimeout);
686
554
  });
687
555
 
688
556
  describe('#disableHostedZoneDNSSEC - errors', () => {
689
557
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
690
- if (pronghorn.methodsByName.disableHostedZoneDNSSEC.task) {
691
- try {
692
- a.disableHostedZoneDNSSEC(Id, (data, error) => {
693
- try {
694
- if (stub) {
695
- const displayE = 'Error 400 received on request';
696
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
697
- } else {
698
- runCommonAsserts(data, error);
699
- }
700
- saveMockData('20130401', 'disableHostedZoneDNSSEC', 'default', data);
701
- done();
702
- } catch (err) {
703
- log.error(`Test Failure: ${err}`);
704
- done(err);
705
- }
706
- });
707
- } catch (error) {
708
- log.error(`Adapter Exception: ${error}`);
709
- done(error);
710
- }
711
- } else {
712
- log.error('disableHostedZoneDNSSEC task is false, skipping test');
713
- skipCount += 1;
714
- done();
715
- }// end if task
558
+ try {
559
+ a.disableHostedZoneDNSSEC(Id, (data, error) => {
560
+ try {
561
+ if (stub) {
562
+ const displayE = 'Error 400 received on request';
563
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
564
+ } else {
565
+ runCommonAsserts(data, error);
566
+ }
567
+ saveMockData('20130401', 'disableHostedZoneDNSSEC', 'default', data);
568
+ done();
569
+ } catch (err) {
570
+ log.error(`Test Failure: ${err}`);
571
+ done(err);
572
+ }
573
+ });
574
+ } catch (error) {
575
+ log.error(`Adapter Exception: ${error}`);
576
+ done(error);
577
+ }
716
578
  }).timeout(attemptTimeout);
717
579
  });
718
580
 
719
581
  const DisassociateVPCFromHostedZoneBodyParam = '<xml>fakedata</xml>';
720
582
  describe('#disassociateVPCFromHostedZone - errors', () => {
721
583
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
722
- if (pronghorn.methodsByName.disassociateVPCFromHostedZone.task) {
723
- try {
724
- a.disassociateVPCFromHostedZone(Id, DisassociateVPCFromHostedZoneBodyParam, (data, error) => {
725
- try {
726
- if (stub) {
727
- const displayE = 'Error 400 received on request';
728
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
729
- } else {
730
- runCommonAsserts(data, error);
731
- }
732
- saveMockData('20130401', 'disassociateVPCFromHostedZone', 'default', data);
733
- done();
734
- } catch (err) {
735
- log.error(`Test Failure: ${err}`);
736
- done(err);
737
- }
738
- });
739
- } catch (error) {
740
- log.error(`Adapter Exception: ${error}`);
741
- done(error);
742
- }
743
- } else {
744
- log.error('disassociateVPCFromHostedZone task is false, skipping test');
745
- skipCount += 1;
746
- done();
747
- }// end if task
584
+ try {
585
+ a.disassociateVPCFromHostedZone(Id, DisassociateVPCFromHostedZoneBodyParam, (data, error) => {
586
+ try {
587
+ if (stub) {
588
+ const displayE = 'Error 400 received on request';
589
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
590
+ } else {
591
+ runCommonAsserts(data, error);
592
+ }
593
+ saveMockData('20130401', 'disassociateVPCFromHostedZone', 'default', data);
594
+ done();
595
+ } catch (err) {
596
+ log.error(`Test Failure: ${err}`);
597
+ done(err);
598
+ }
599
+ });
600
+ } catch (error) {
601
+ log.error(`Adapter Exception: ${error}`);
602
+ done(error);
603
+ }
748
604
  }).timeout(attemptTimeout);
749
605
  });
750
606
 
751
607
  describe('#enableHostedZoneDNSSEC - errors', () => {
752
608
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
753
- if (pronghorn.methodsByName.enableHostedZoneDNSSEC.task) {
754
- try {
755
- a.enableHostedZoneDNSSEC(Id, (data, error) => {
756
- try {
757
- if (stub) {
758
- const displayE = 'Error 400 received on request';
759
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
760
- } else {
761
- runCommonAsserts(data, error);
762
- }
763
- saveMockData('20130401', 'enableHostedZoneDNSSEC', 'default', data);
764
- done();
765
- } catch (err) {
766
- log.error(`Test Failure: ${err}`);
767
- done(err);
768
- }
769
- });
770
- } catch (error) {
771
- log.error(`Adapter Exception: ${error}`);
772
- done(error);
773
- }
774
- } else {
775
- log.error('enableHostedZoneDNSSEC task is false, skipping test');
776
- skipCount += 1;
777
- done();
778
- }// end if task
609
+ try {
610
+ a.enableHostedZoneDNSSEC(Id, (data, error) => {
611
+ try {
612
+ if (stub) {
613
+ const displayE = 'Error 400 received on request';
614
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
615
+ } else {
616
+ runCommonAsserts(data, error);
617
+ }
618
+ saveMockData('20130401', 'enableHostedZoneDNSSEC', 'default', data);
619
+ done();
620
+ } catch (err) {
621
+ log.error(`Test Failure: ${err}`);
622
+ done(err);
623
+ }
624
+ });
625
+ } catch (error) {
626
+ log.error(`Adapter Exception: ${error}`);
627
+ done(error);
628
+ }
779
629
  }).timeout(attemptTimeout);
780
630
  });
781
631
 
782
632
  const ChangeResourceRecordSetsBodyParam = '<xml>fakedata</xml>';
783
633
  describe('#changeResourceRecordSets - errors', () => {
784
634
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
785
- if (pronghorn.methodsByName.changeResourceRecordSets.task) {
786
- try {
787
- a.changeResourceRecordSets(Id, ChangeResourceRecordSetsBodyParam, (data, error) => {
788
- try {
789
- if (stub) {
790
- const displayE = 'Error 400 received on request';
791
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
792
- } else {
793
- runCommonAsserts(data, error);
794
- }
795
- saveMockData('20130401', 'changeResourceRecordSets', 'default', data);
796
- done();
797
- } catch (err) {
798
- log.error(`Test Failure: ${err}`);
799
- done(err);
800
- }
801
- });
802
- } catch (error) {
803
- log.error(`Adapter Exception: ${error}`);
804
- done(error);
805
- }
806
- } else {
807
- log.error('changeResourceRecordSets task is false, skipping test');
808
- skipCount += 1;
809
- done();
810
- }// end if task
635
+ try {
636
+ a.changeResourceRecordSets(Id, ChangeResourceRecordSetsBodyParam, (data, error) => {
637
+ try {
638
+ if (stub) {
639
+ const displayE = 'Error 400 received on request';
640
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
641
+ } else {
642
+ runCommonAsserts(data, error);
643
+ }
644
+ saveMockData('20130401', 'changeResourceRecordSets', 'default', data);
645
+ done();
646
+ } catch (err) {
647
+ log.error(`Test Failure: ${err}`);
648
+ done(err);
649
+ }
650
+ });
651
+ } catch (error) {
652
+ log.error(`Adapter Exception: ${error}`);
653
+ done(error);
654
+ }
811
655
  }).timeout(attemptTimeout);
812
656
  });
813
657
 
814
658
  const CreateKeySigningKeyBodyParam = '<xml>fakedata</xml>';
815
659
  describe('#createKeySigningKey - errors', () => {
816
660
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
817
- if (pronghorn.methodsByName.createKeySigningKey.task) {
818
- try {
819
- a.createKeySigningKey(CreateKeySigningKeyBodyParam, (data, error) => {
820
- try {
821
- if (stub) {
822
- const displayE = 'Error 400 received on request';
823
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
824
- } else {
825
- runCommonAsserts(data, error);
826
- }
827
- saveMockData('20130401', 'createKeySigningKey', 'default', data);
828
- done();
829
- } catch (err) {
830
- log.error(`Test Failure: ${err}`);
831
- done(err);
832
- }
833
- });
834
- } catch (error) {
835
- log.error(`Adapter Exception: ${error}`);
836
- done(error);
837
- }
838
- } else {
839
- log.error('createKeySigningKey task is false, skipping test');
840
- skipCount += 1;
841
- done();
842
- }// end if task
661
+ try {
662
+ a.createKeySigningKey(CreateKeySigningKeyBodyParam, (data, error) => {
663
+ try {
664
+ if (stub) {
665
+ const displayE = 'Error 400 received on request';
666
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
667
+ } else {
668
+ runCommonAsserts(data, error);
669
+ }
670
+ saveMockData('20130401', 'createKeySigningKey', 'default', data);
671
+ done();
672
+ } catch (err) {
673
+ log.error(`Test Failure: ${err}`);
674
+ done(err);
675
+ }
676
+ });
677
+ } catch (error) {
678
+ log.error(`Adapter Exception: ${error}`);
679
+ done(error);
680
+ }
843
681
  }).timeout(attemptTimeout);
844
682
  });
845
683
 
@@ -847,95 +685,77 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
847
685
  const Name = 'fakedata';
848
686
  describe('#activateKeySigningKey - errors', () => {
849
687
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
850
- if (pronghorn.methodsByName.activateKeySigningKey.task) {
851
- try {
852
- a.activateKeySigningKey(HostedZoneId, Name, (data, error) => {
853
- try {
854
- if (stub) {
855
- const displayE = 'Error 400 received on request';
856
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
857
- } else {
858
- runCommonAsserts(data, error);
859
- }
860
- saveMockData('20130401', 'activateKeySigningKey', 'default', data);
861
- done();
862
- } catch (err) {
863
- log.error(`Test Failure: ${err}`);
864
- done(err);
865
- }
866
- });
867
- } catch (error) {
868
- log.error(`Adapter Exception: ${error}`);
869
- done(error);
870
- }
871
- } else {
872
- log.error('activateKeySigningKey task is false, skipping test');
873
- skipCount += 1;
874
- done();
875
- }// end if task
876
- }).timeout(attemptTimeout);
877
- });
878
-
879
- describe('#deactivateKeySigningKey - errors', () => {
880
- it('should work if integrated but since no mockdata should error when run standalone', (done) => {
881
- if (pronghorn.methodsByName.deactivateKeySigningKey.task) {
882
- try {
883
- a.deactivateKeySigningKey(HostedZoneId, Name, (data, error) => {
884
- try {
885
- if (stub) {
886
- const displayE = 'Error 400 received on request';
887
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
888
- } else {
889
- runCommonAsserts(data, error);
890
- }
891
- saveMockData('20130401', 'deactivateKeySigningKey', 'default', data);
892
- done();
893
- } catch (err) {
894
- log.error(`Test Failure: ${err}`);
895
- done(err);
896
- }
897
- });
898
- } catch (error) {
899
- log.error(`Adapter Exception: ${error}`);
900
- done(error);
901
- }
902
- } else {
903
- log.error('deactivateKeySigningKey task is false, skipping test');
904
- skipCount += 1;
905
- done();
906
- }// end if task
688
+ try {
689
+ a.activateKeySigningKey(HostedZoneId, Name, (data, error) => {
690
+ try {
691
+ if (stub) {
692
+ const displayE = 'Error 400 received on request';
693
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
694
+ } else {
695
+ runCommonAsserts(data, error);
696
+ }
697
+ saveMockData('20130401', 'activateKeySigningKey', 'default', data);
698
+ done();
699
+ } catch (err) {
700
+ log.error(`Test Failure: ${err}`);
701
+ done(err);
702
+ }
703
+ });
704
+ } catch (error) {
705
+ log.error(`Adapter Exception: ${error}`);
706
+ done(error);
707
+ }
708
+ }).timeout(attemptTimeout);
709
+ });
710
+
711
+ describe('#deactivateKeySigningKey - errors', () => {
712
+ it('should work if integrated but since no mockdata should error when run standalone', (done) => {
713
+ try {
714
+ a.deactivateKeySigningKey(HostedZoneId, Name, (data, error) => {
715
+ try {
716
+ if (stub) {
717
+ const displayE = 'Error 400 received on request';
718
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
719
+ } else {
720
+ runCommonAsserts(data, error);
721
+ }
722
+ saveMockData('20130401', 'deactivateKeySigningKey', 'default', data);
723
+ done();
724
+ } catch (err) {
725
+ log.error(`Test Failure: ${err}`);
726
+ done(err);
727
+ }
728
+ });
729
+ } catch (error) {
730
+ log.error(`Adapter Exception: ${error}`);
731
+ done(error);
732
+ }
907
733
  }).timeout(attemptTimeout);
908
734
  });
909
735
 
910
736
  const CreateQueryLoggingConfigBodyParam = '<xml>fakedata</xml>';
911
737
  describe('#createQueryLoggingConfig - errors', () => {
912
738
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
913
- if (pronghorn.methodsByName.createQueryLoggingConfig.task) {
914
- try {
915
- a.createQueryLoggingConfig(CreateQueryLoggingConfigBodyParam, (data, error) => {
916
- try {
917
- if (stub) {
918
- const displayE = 'Error 400 received on request';
919
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
920
- } else {
921
- runCommonAsserts(data, error);
922
- }
923
- saveMockData('20130401', 'createQueryLoggingConfig', 'default', data);
924
- done();
925
- } catch (err) {
926
- log.error(`Test Failure: ${err}`);
927
- done(err);
928
- }
929
- });
930
- } catch (error) {
931
- log.error(`Adapter Exception: ${error}`);
932
- done(error);
933
- }
934
- } else {
935
- log.error('createQueryLoggingConfig task is false, skipping test');
936
- skipCount += 1;
937
- done();
938
- }// end if task
739
+ try {
740
+ a.createQueryLoggingConfig(CreateQueryLoggingConfigBodyParam, (data, error) => {
741
+ try {
742
+ if (stub) {
743
+ const displayE = 'Error 400 received on request';
744
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
745
+ } else {
746
+ runCommonAsserts(data, error);
747
+ }
748
+ saveMockData('20130401', 'createQueryLoggingConfig', 'default', data);
749
+ done();
750
+ } catch (err) {
751
+ log.error(`Test Failure: ${err}`);
752
+ done(err);
753
+ }
754
+ });
755
+ } catch (error) {
756
+ log.error(`Adapter Exception: ${error}`);
757
+ done(error);
758
+ }
939
759
  }).timeout(attemptTimeout);
940
760
  });
941
761
 
@@ -943,32 +763,26 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
943
763
  const ListTagsForResourcesBodyParam = '<xml>fakedata</xml>';
944
764
  describe('#listTagsForResources - errors', () => {
945
765
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
946
- if (pronghorn.methodsByName.listTagsForResources.task) {
947
- try {
948
- a.listTagsForResources(ResourceType, ListTagsForResourcesBodyParam, (data, error) => {
949
- try {
950
- if (stub) {
951
- const displayE = 'Error 400 received on request';
952
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
953
- } else {
954
- runCommonAsserts(data, error);
955
- }
956
- saveMockData('20130401', 'listTagsForResources', 'default', data);
957
- done();
958
- } catch (err) {
959
- log.error(`Test Failure: ${err}`);
960
- done(err);
961
- }
962
- });
963
- } catch (error) {
964
- log.error(`Adapter Exception: ${error}`);
965
- done(error);
966
- }
967
- } else {
968
- log.error('listTagsForResources task is false, skipping test');
969
- skipCount += 1;
970
- done();
971
- }// end if task
766
+ try {
767
+ a.listTagsForResources(ResourceType, ListTagsForResourcesBodyParam, (data, error) => {
768
+ try {
769
+ if (stub) {
770
+ const displayE = 'Error 400 received on request';
771
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
772
+ } else {
773
+ runCommonAsserts(data, error);
774
+ }
775
+ saveMockData('20130401', 'listTagsForResources', 'default', data);
776
+ done();
777
+ } catch (err) {
778
+ log.error(`Test Failure: ${err}`);
779
+ done(err);
780
+ }
781
+ });
782
+ } catch (error) {
783
+ log.error(`Adapter Exception: ${error}`);
784
+ done(error);
785
+ }
972
786
  }).timeout(attemptTimeout);
973
787
  });
974
788
 
@@ -976,96 +790,78 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
976
790
  const ChangeTagsForResourceBodyParam = '<xml>fakedata</xml>';
977
791
  describe('#changeTagsForResource - errors', () => {
978
792
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
979
- if (pronghorn.methodsByName.changeTagsForResource.task) {
980
- try {
981
- a.changeTagsForResource(ResourceType, ResourceId, ChangeTagsForResourceBodyParam, (data, error) => {
982
- try {
983
- if (stub) {
984
- const displayE = 'Error 400 received on request';
985
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
986
- } else {
987
- runCommonAsserts(data, error);
988
- }
989
- saveMockData('20130401', 'changeTagsForResource', 'default', data);
990
- done();
991
- } catch (err) {
992
- log.error(`Test Failure: ${err}`);
993
- done(err);
994
- }
995
- });
996
- } catch (error) {
997
- log.error(`Adapter Exception: ${error}`);
998
- done(error);
999
- }
1000
- } else {
1001
- log.error('changeTagsForResource task is false, skipping test');
1002
- skipCount += 1;
1003
- done();
1004
- }// end if task
793
+ try {
794
+ a.changeTagsForResource(ResourceType, ResourceId, ChangeTagsForResourceBodyParam, (data, error) => {
795
+ try {
796
+ if (stub) {
797
+ const displayE = 'Error 400 received on request';
798
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
799
+ } else {
800
+ runCommonAsserts(data, error);
801
+ }
802
+ saveMockData('20130401', 'changeTagsForResource', 'default', data);
803
+ done();
804
+ } catch (err) {
805
+ log.error(`Test Failure: ${err}`);
806
+ done(err);
807
+ }
808
+ });
809
+ } catch (error) {
810
+ log.error(`Adapter Exception: ${error}`);
811
+ done(error);
812
+ }
1005
813
  }).timeout(attemptTimeout);
1006
814
  });
1007
815
 
1008
816
  const CreateTrafficPolicyBodyParam = '<xml>fakedata</xml>';
1009
817
  describe('#createTrafficPolicy - errors', () => {
1010
818
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1011
- if (pronghorn.methodsByName.createTrafficPolicy.task) {
1012
- try {
1013
- a.createTrafficPolicy(CreateTrafficPolicyBodyParam, (data, error) => {
1014
- try {
1015
- if (stub) {
1016
- const displayE = 'Error 400 received on request';
1017
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1018
- } else {
1019
- runCommonAsserts(data, error);
1020
- }
1021
- saveMockData('20130401', 'createTrafficPolicy', 'default', data);
1022
- done();
1023
- } catch (err) {
1024
- log.error(`Test Failure: ${err}`);
1025
- done(err);
1026
- }
1027
- });
1028
- } catch (error) {
1029
- log.error(`Adapter Exception: ${error}`);
1030
- done(error);
1031
- }
1032
- } else {
1033
- log.error('createTrafficPolicy task is false, skipping test');
1034
- skipCount += 1;
1035
- done();
1036
- }// end if task
819
+ try {
820
+ a.createTrafficPolicy(CreateTrafficPolicyBodyParam, (data, error) => {
821
+ try {
822
+ if (stub) {
823
+ const displayE = 'Error 400 received on request';
824
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
825
+ } else {
826
+ runCommonAsserts(data, error);
827
+ }
828
+ saveMockData('20130401', 'createTrafficPolicy', 'default', data);
829
+ done();
830
+ } catch (err) {
831
+ log.error(`Test Failure: ${err}`);
832
+ done(err);
833
+ }
834
+ });
835
+ } catch (error) {
836
+ log.error(`Adapter Exception: ${error}`);
837
+ done(error);
838
+ }
1037
839
  }).timeout(attemptTimeout);
1038
840
  });
1039
841
 
1040
842
  const CreateTrafficPolicyVersionBodyParam = '<xml>fakedata</xml>';
1041
843
  describe('#createTrafficPolicyVersion - errors', () => {
1042
844
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1043
- if (pronghorn.methodsByName.createTrafficPolicyVersion.task) {
1044
- try {
1045
- a.createTrafficPolicyVersion(Id, CreateTrafficPolicyVersionBodyParam, (data, error) => {
1046
- try {
1047
- if (stub) {
1048
- const displayE = 'Error 400 received on request';
1049
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1050
- } else {
1051
- runCommonAsserts(data, error);
1052
- }
1053
- saveMockData('20130401', 'createTrafficPolicyVersion', 'default', data);
1054
- done();
1055
- } catch (err) {
1056
- log.error(`Test Failure: ${err}`);
1057
- done(err);
1058
- }
1059
- });
1060
- } catch (error) {
1061
- log.error(`Adapter Exception: ${error}`);
1062
- done(error);
1063
- }
1064
- } else {
1065
- log.error('createTrafficPolicyVersion task is false, skipping test');
1066
- skipCount += 1;
1067
- done();
1068
- }// end if task
845
+ try {
846
+ a.createTrafficPolicyVersion(Id, CreateTrafficPolicyVersionBodyParam, (data, error) => {
847
+ try {
848
+ if (stub) {
849
+ const displayE = 'Error 400 received on request';
850
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
851
+ } else {
852
+ runCommonAsserts(data, error);
853
+ }
854
+ saveMockData('20130401', 'createTrafficPolicyVersion', 'default', data);
855
+ done();
856
+ } catch (err) {
857
+ log.error(`Test Failure: ${err}`);
858
+ done(err);
859
+ }
860
+ });
861
+ } catch (error) {
862
+ log.error(`Adapter Exception: ${error}`);
863
+ done(error);
864
+ }
1069
865
  }).timeout(attemptTimeout);
1070
866
  });
1071
867
 
@@ -1073,718 +869,580 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
1073
869
  const UpdateTrafficPolicyCommentBodyParam = '<xml>fakedata</xml>';
1074
870
  describe('#updateTrafficPolicyComment - errors', () => {
1075
871
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1076
- if (pronghorn.methodsByName.updateTrafficPolicyComment.task) {
1077
- try {
1078
- a.updateTrafficPolicyComment(Id, Version, UpdateTrafficPolicyCommentBodyParam, (data, error) => {
1079
- try {
1080
- if (stub) {
1081
- const displayE = 'Error 400 received on request';
1082
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1083
- } else {
1084
- runCommonAsserts(data, error);
1085
- }
1086
- saveMockData('20130401', 'updateTrafficPolicyComment', 'default', data);
1087
- done();
1088
- } catch (err) {
1089
- log.error(`Test Failure: ${err}`);
1090
- done(err);
1091
- }
1092
- });
1093
- } catch (error) {
1094
- log.error(`Adapter Exception: ${error}`);
1095
- done(error);
1096
- }
1097
- } else {
1098
- log.error('updateTrafficPolicyComment task is false, skipping test');
1099
- skipCount += 1;
1100
- done();
1101
- }// end if task
872
+ try {
873
+ a.updateTrafficPolicyComment(Id, Version, UpdateTrafficPolicyCommentBodyParam, (data, error) => {
874
+ try {
875
+ if (stub) {
876
+ const displayE = 'Error 400 received on request';
877
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
878
+ } else {
879
+ runCommonAsserts(data, error);
880
+ }
881
+ saveMockData('20130401', 'updateTrafficPolicyComment', 'default', data);
882
+ done();
883
+ } catch (err) {
884
+ log.error(`Test Failure: ${err}`);
885
+ done(err);
886
+ }
887
+ });
888
+ } catch (error) {
889
+ log.error(`Adapter Exception: ${error}`);
890
+ done(error);
891
+ }
1102
892
  }).timeout(attemptTimeout);
1103
893
  });
1104
894
 
1105
895
  const CreateTrafficPolicyInstanceBodyParam = '<xml>fakedata</xml>';
1106
896
  describe('#createTrafficPolicyInstance - errors', () => {
1107
897
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1108
- if (pronghorn.methodsByName.createTrafficPolicyInstance.task) {
1109
- try {
1110
- a.createTrafficPolicyInstance(CreateTrafficPolicyInstanceBodyParam, (data, error) => {
1111
- try {
1112
- if (stub) {
1113
- const displayE = 'Error 400 received on request';
1114
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1115
- } else {
1116
- runCommonAsserts(data, error);
1117
- }
1118
- saveMockData('20130401', 'createTrafficPolicyInstance', 'default', data);
1119
- done();
1120
- } catch (err) {
1121
- log.error(`Test Failure: ${err}`);
1122
- done(err);
1123
- }
1124
- });
1125
- } catch (error) {
1126
- log.error(`Adapter Exception: ${error}`);
1127
- done(error);
1128
- }
1129
- } else {
1130
- log.error('createTrafficPolicyInstance task is false, skipping test');
1131
- skipCount += 1;
1132
- done();
1133
- }// end if task
898
+ try {
899
+ a.createTrafficPolicyInstance(CreateTrafficPolicyInstanceBodyParam, (data, error) => {
900
+ try {
901
+ if (stub) {
902
+ const displayE = 'Error 400 received on request';
903
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
904
+ } else {
905
+ runCommonAsserts(data, error);
906
+ }
907
+ saveMockData('20130401', 'createTrafficPolicyInstance', 'default', data);
908
+ done();
909
+ } catch (err) {
910
+ log.error(`Test Failure: ${err}`);
911
+ done(err);
912
+ }
913
+ });
914
+ } catch (error) {
915
+ log.error(`Adapter Exception: ${error}`);
916
+ done(error);
917
+ }
1134
918
  }).timeout(attemptTimeout);
1135
919
  });
1136
920
 
1137
921
  const UpdateTrafficPolicyInstanceBodyParam = '<xml>fakedata</xml>';
1138
922
  describe('#updateTrafficPolicyInstance - errors', () => {
1139
923
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1140
- if (pronghorn.methodsByName.updateTrafficPolicyInstance.task) {
1141
- try {
1142
- a.updateTrafficPolicyInstance(Id, UpdateTrafficPolicyInstanceBodyParam, (data, error) => {
1143
- try {
1144
- if (stub) {
1145
- const displayE = 'Error 400 received on request';
1146
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1147
- } else {
1148
- runCommonAsserts(data, error);
1149
- }
1150
- saveMockData('20130401', 'updateTrafficPolicyInstance', 'default', data);
1151
- done();
1152
- } catch (err) {
1153
- log.error(`Test Failure: ${err}`);
1154
- done(err);
1155
- }
1156
- });
1157
- } catch (error) {
1158
- log.error(`Adapter Exception: ${error}`);
1159
- done(error);
1160
- }
1161
- } else {
1162
- log.error('updateTrafficPolicyInstance task is false, skipping test');
1163
- skipCount += 1;
1164
- done();
1165
- }// end if task
924
+ try {
925
+ a.updateTrafficPolicyInstance(Id, UpdateTrafficPolicyInstanceBodyParam, (data, error) => {
926
+ try {
927
+ if (stub) {
928
+ const displayE = 'Error 400 received on request';
929
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
930
+ } else {
931
+ runCommonAsserts(data, error);
932
+ }
933
+ saveMockData('20130401', 'updateTrafficPolicyInstance', 'default', data);
934
+ done();
935
+ } catch (err) {
936
+ log.error(`Test Failure: ${err}`);
937
+ done(err);
938
+ }
939
+ });
940
+ } catch (error) {
941
+ log.error(`Adapter Exception: ${error}`);
942
+ done(error);
943
+ }
1166
944
  }).timeout(attemptTimeout);
1167
945
  });
1168
946
 
1169
947
  const Type = 'fakedata';
1170
948
  describe('#getAccountLimit - errors', () => {
1171
949
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1172
- if (pronghorn.methodsByName.getAccountLimit.task) {
1173
- try {
1174
- a.getAccountLimit(Type, (data, error) => {
1175
- try {
1176
- if (stub) {
1177
- const displayE = 'Error 400 received on request';
1178
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1179
- } else {
1180
- runCommonAsserts(data, error);
1181
- }
1182
- saveMockData('20130401', 'getAccountLimit', 'default', data);
1183
- done();
1184
- } catch (err) {
1185
- log.error(`Test Failure: ${err}`);
1186
- done(err);
1187
- }
1188
- });
1189
- } catch (error) {
1190
- log.error(`Adapter Exception: ${error}`);
1191
- done(error);
1192
- }
1193
- } else {
1194
- log.error('getAccountLimit task is false, skipping test');
1195
- skipCount += 1;
1196
- done();
1197
- }// end if task
950
+ try {
951
+ a.getAccountLimit(Type, (data, error) => {
952
+ try {
953
+ if (stub) {
954
+ const displayE = 'Error 400 received on request';
955
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
956
+ } else {
957
+ runCommonAsserts(data, error);
958
+ }
959
+ saveMockData('20130401', 'getAccountLimit', 'default', data);
960
+ done();
961
+ } catch (err) {
962
+ log.error(`Test Failure: ${err}`);
963
+ done(err);
964
+ }
965
+ });
966
+ } catch (error) {
967
+ log.error(`Adapter Exception: ${error}`);
968
+ done(error);
969
+ }
1198
970
  }).timeout(attemptTimeout);
1199
971
  });
1200
972
 
1201
973
  describe('#getChange - errors', () => {
1202
974
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1203
- if (pronghorn.methodsByName.getChange.task) {
1204
- try {
1205
- a.getChange(Id, (data, error) => {
1206
- try {
1207
- if (stub) {
1208
- const displayE = 'Error 400 received on request';
1209
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1210
- } else {
1211
- runCommonAsserts(data, error);
1212
- }
1213
- saveMockData('20130401', 'getChange', 'default', data);
1214
- done();
1215
- } catch (err) {
1216
- log.error(`Test Failure: ${err}`);
1217
- done(err);
1218
- }
1219
- });
1220
- } catch (error) {
1221
- log.error(`Adapter Exception: ${error}`);
1222
- done(error);
1223
- }
1224
- } else {
1225
- log.error('getChange task is false, skipping test');
1226
- skipCount += 1;
1227
- done();
1228
- }// end if task
975
+ try {
976
+ a.getChange(Id, (data, error) => {
977
+ try {
978
+ if (stub) {
979
+ const displayE = 'Error 400 received on request';
980
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
981
+ } else {
982
+ runCommonAsserts(data, error);
983
+ }
984
+ saveMockData('20130401', 'getChange', 'default', data);
985
+ done();
986
+ } catch (err) {
987
+ log.error(`Test Failure: ${err}`);
988
+ done(err);
989
+ }
990
+ });
991
+ } catch (error) {
992
+ log.error(`Adapter Exception: ${error}`);
993
+ done(error);
994
+ }
1229
995
  }).timeout(attemptTimeout);
1230
996
  });
1231
997
 
1232
998
  describe('#getCheckerIpRanges - errors', () => {
1233
999
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1234
- if (pronghorn.methodsByName.getCheckerIpRanges.task) {
1235
- try {
1236
- a.getCheckerIpRanges((data, error) => {
1237
- try {
1238
- if (stub) {
1239
- const displayE = 'Error 400 received on request';
1240
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1241
- } else {
1242
- runCommonAsserts(data, error);
1243
- }
1244
- saveMockData('20130401', 'getCheckerIpRanges', 'default', data);
1245
- done();
1246
- } catch (err) {
1247
- log.error(`Test Failure: ${err}`);
1248
- done(err);
1249
- }
1250
- });
1251
- } catch (error) {
1252
- log.error(`Adapter Exception: ${error}`);
1253
- done(error);
1254
- }
1255
- } else {
1256
- log.error('getCheckerIpRanges task is false, skipping test');
1257
- skipCount += 1;
1258
- done();
1259
- }// end if task
1000
+ try {
1001
+ a.getCheckerIpRanges((data, error) => {
1002
+ try {
1003
+ if (stub) {
1004
+ const displayE = 'Error 400 received on request';
1005
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1006
+ } else {
1007
+ runCommonAsserts(data, error);
1008
+ }
1009
+ saveMockData('20130401', 'getCheckerIpRanges', 'default', data);
1010
+ done();
1011
+ } catch (err) {
1012
+ log.error(`Test Failure: ${err}`);
1013
+ done(err);
1014
+ }
1015
+ });
1016
+ } catch (error) {
1017
+ log.error(`Adapter Exception: ${error}`);
1018
+ done(error);
1019
+ }
1260
1020
  }).timeout(attemptTimeout);
1261
1021
  });
1262
1022
 
1263
1023
  describe('#listReusableDelegationSets - errors', () => {
1264
1024
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1265
- if (pronghorn.methodsByName.listReusableDelegationSets.task) {
1266
- try {
1267
- a.listReusableDelegationSets(null, null, (data, error) => {
1268
- try {
1269
- if (stub) {
1270
- const displayE = 'Error 400 received on request';
1271
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1272
- } else {
1273
- runCommonAsserts(data, error);
1274
- }
1275
- saveMockData('20130401', 'listReusableDelegationSets', 'default', data);
1276
- done();
1277
- } catch (err) {
1278
- log.error(`Test Failure: ${err}`);
1279
- done(err);
1280
- }
1281
- });
1282
- } catch (error) {
1283
- log.error(`Adapter Exception: ${error}`);
1284
- done(error);
1285
- }
1286
- } else {
1287
- log.error('listReusableDelegationSets task is false, skipping test');
1288
- skipCount += 1;
1289
- done();
1290
- }// end if task
1025
+ try {
1026
+ a.listReusableDelegationSets(null, null, (data, error) => {
1027
+ try {
1028
+ if (stub) {
1029
+ const displayE = 'Error 400 received on request';
1030
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1031
+ } else {
1032
+ runCommonAsserts(data, error);
1033
+ }
1034
+ saveMockData('20130401', 'listReusableDelegationSets', 'default', data);
1035
+ done();
1036
+ } catch (err) {
1037
+ log.error(`Test Failure: ${err}`);
1038
+ done(err);
1039
+ }
1040
+ });
1041
+ } catch (error) {
1042
+ log.error(`Adapter Exception: ${error}`);
1043
+ done(error);
1044
+ }
1291
1045
  }).timeout(attemptTimeout);
1292
1046
  });
1293
1047
 
1294
1048
  describe('#getReusableDelegationSet - errors', () => {
1295
1049
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1296
- if (pronghorn.methodsByName.getReusableDelegationSet.task) {
1297
- try {
1298
- a.getReusableDelegationSet(Id, (data, error) => {
1299
- try {
1300
- if (stub) {
1301
- const displayE = 'Error 400 received on request';
1302
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1303
- } else {
1304
- runCommonAsserts(data, error);
1305
- }
1306
- saveMockData('20130401', 'getReusableDelegationSet', 'default', data);
1307
- done();
1308
- } catch (err) {
1309
- log.error(`Test Failure: ${err}`);
1310
- done(err);
1311
- }
1312
- });
1313
- } catch (error) {
1314
- log.error(`Adapter Exception: ${error}`);
1315
- done(error);
1316
- }
1317
- } else {
1318
- log.error('getReusableDelegationSet task is false, skipping test');
1319
- skipCount += 1;
1320
- done();
1321
- }// end if task
1322
- }).timeout(attemptTimeout);
1323
- });
1324
-
1325
- describe('#getGeoLocation - errors', () => {
1050
+ try {
1051
+ a.getReusableDelegationSet(Id, (data, error) => {
1052
+ try {
1053
+ if (stub) {
1054
+ const displayE = 'Error 400 received on request';
1055
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1056
+ } else {
1057
+ runCommonAsserts(data, error);
1058
+ }
1059
+ saveMockData('20130401', 'getReusableDelegationSet', 'default', data);
1060
+ done();
1061
+ } catch (err) {
1062
+ log.error(`Test Failure: ${err}`);
1063
+ done(err);
1064
+ }
1065
+ });
1066
+ } catch (error) {
1067
+ log.error(`Adapter Exception: ${error}`);
1068
+ done(error);
1069
+ }
1070
+ }).timeout(attemptTimeout);
1071
+ });
1072
+
1073
+ describe('#getGeoLocation - errors', () => {
1326
1074
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1327
- if (pronghorn.methodsByName.getGeoLocation.task) {
1328
- try {
1329
- a.getGeoLocation(null, null, null, (data, error) => {
1330
- try {
1331
- if (stub) {
1332
- const displayE = 'Error 400 received on request';
1333
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1334
- } else {
1335
- runCommonAsserts(data, error);
1336
- }
1337
- saveMockData('20130401', 'getGeoLocation', 'default', data);
1338
- done();
1339
- } catch (err) {
1340
- log.error(`Test Failure: ${err}`);
1341
- done(err);
1342
- }
1343
- });
1344
- } catch (error) {
1345
- log.error(`Adapter Exception: ${error}`);
1346
- done(error);
1347
- }
1348
- } else {
1349
- log.error('getGeoLocation task is false, skipping test');
1350
- skipCount += 1;
1351
- done();
1352
- }// end if task
1075
+ try {
1076
+ a.getGeoLocation(null, null, null, (data, error) => {
1077
+ try {
1078
+ if (stub) {
1079
+ const displayE = 'Error 400 received on request';
1080
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1081
+ } else {
1082
+ runCommonAsserts(data, error);
1083
+ }
1084
+ saveMockData('20130401', 'getGeoLocation', 'default', data);
1085
+ done();
1086
+ } catch (err) {
1087
+ log.error(`Test Failure: ${err}`);
1088
+ done(err);
1089
+ }
1090
+ });
1091
+ } catch (error) {
1092
+ log.error(`Adapter Exception: ${error}`);
1093
+ done(error);
1094
+ }
1353
1095
  }).timeout(attemptTimeout);
1354
1096
  });
1355
1097
 
1356
1098
  describe('#listGeoLocations - errors', () => {
1357
1099
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1358
- if (pronghorn.methodsByName.listGeoLocations.task) {
1359
- try {
1360
- a.listGeoLocations(null, null, null, null, (data, error) => {
1361
- try {
1362
- if (stub) {
1363
- const displayE = 'Error 400 received on request';
1364
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1365
- } else {
1366
- runCommonAsserts(data, error);
1367
- }
1368
- saveMockData('20130401', 'listGeoLocations', 'default', data);
1369
- done();
1370
- } catch (err) {
1371
- log.error(`Test Failure: ${err}`);
1372
- done(err);
1373
- }
1374
- });
1375
- } catch (error) {
1376
- log.error(`Adapter Exception: ${error}`);
1377
- done(error);
1378
- }
1379
- } else {
1380
- log.error('listGeoLocations task is false, skipping test');
1381
- skipCount += 1;
1382
- done();
1383
- }// end if task
1100
+ try {
1101
+ a.listGeoLocations(null, null, null, null, (data, error) => {
1102
+ try {
1103
+ if (stub) {
1104
+ const displayE = 'Error 400 received on request';
1105
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1106
+ } else {
1107
+ runCommonAsserts(data, error);
1108
+ }
1109
+ saveMockData('20130401', 'listGeoLocations', 'default', data);
1110
+ done();
1111
+ } catch (err) {
1112
+ log.error(`Test Failure: ${err}`);
1113
+ done(err);
1114
+ }
1115
+ });
1116
+ } catch (error) {
1117
+ log.error(`Adapter Exception: ${error}`);
1118
+ done(error);
1119
+ }
1384
1120
  }).timeout(attemptTimeout);
1385
1121
  });
1386
1122
 
1387
1123
  describe('#listHealthChecks - errors', () => {
1388
1124
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1389
- if (pronghorn.methodsByName.listHealthChecks.task) {
1390
- try {
1391
- a.listHealthChecks(null, null, null, null, (data, error) => {
1392
- try {
1393
- if (stub) {
1394
- const displayE = 'Error 400 received on request';
1395
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1396
- } else {
1397
- runCommonAsserts(data, error);
1398
- }
1399
- saveMockData('20130401', 'listHealthChecks', 'default', data);
1400
- done();
1401
- } catch (err) {
1402
- log.error(`Test Failure: ${err}`);
1403
- done(err);
1404
- }
1405
- });
1406
- } catch (error) {
1407
- log.error(`Adapter Exception: ${error}`);
1408
- done(error);
1409
- }
1410
- } else {
1411
- log.error('listHealthChecks task is false, skipping test');
1412
- skipCount += 1;
1413
- done();
1414
- }// end if task
1125
+ try {
1126
+ a.listHealthChecks(null, null, null, null, (data, error) => {
1127
+ try {
1128
+ if (stub) {
1129
+ const displayE = 'Error 400 received on request';
1130
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1131
+ } else {
1132
+ runCommonAsserts(data, error);
1133
+ }
1134
+ saveMockData('20130401', 'listHealthChecks', 'default', data);
1135
+ done();
1136
+ } catch (err) {
1137
+ log.error(`Test Failure: ${err}`);
1138
+ done(err);
1139
+ }
1140
+ });
1141
+ } catch (error) {
1142
+ log.error(`Adapter Exception: ${error}`);
1143
+ done(error);
1144
+ }
1415
1145
  }).timeout(attemptTimeout);
1416
1146
  });
1417
1147
 
1418
1148
  describe('#getHealthCheck - errors', () => {
1419
1149
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1420
- if (pronghorn.methodsByName.getHealthCheck.task) {
1421
- try {
1422
- a.getHealthCheck(HealthCheckId, (data, error) => {
1423
- try {
1424
- if (stub) {
1425
- const displayE = 'Error 400 received on request';
1426
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1427
- } else {
1428
- runCommonAsserts(data, error);
1429
- }
1430
- saveMockData('20130401', 'getHealthCheck', 'default', data);
1431
- done();
1432
- } catch (err) {
1433
- log.error(`Test Failure: ${err}`);
1434
- done(err);
1435
- }
1436
- });
1437
- } catch (error) {
1438
- log.error(`Adapter Exception: ${error}`);
1439
- done(error);
1440
- }
1441
- } else {
1442
- log.error('getHealthCheck task is false, skipping test');
1443
- skipCount += 1;
1444
- done();
1445
- }// end if task
1150
+ try {
1151
+ a.getHealthCheck(HealthCheckId, (data, error) => {
1152
+ try {
1153
+ if (stub) {
1154
+ const displayE = 'Error 400 received on request';
1155
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1156
+ } else {
1157
+ runCommonAsserts(data, error);
1158
+ }
1159
+ saveMockData('20130401', 'getHealthCheck', 'default', data);
1160
+ done();
1161
+ } catch (err) {
1162
+ log.error(`Test Failure: ${err}`);
1163
+ done(err);
1164
+ }
1165
+ });
1166
+ } catch (error) {
1167
+ log.error(`Adapter Exception: ${error}`);
1168
+ done(error);
1169
+ }
1446
1170
  }).timeout(attemptTimeout);
1447
1171
  });
1448
1172
 
1449
1173
  describe('#getHealthCheckLastFailureReason - errors', () => {
1450
1174
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1451
- if (pronghorn.methodsByName.getHealthCheckLastFailureReason.task) {
1452
- try {
1453
- a.getHealthCheckLastFailureReason(HealthCheckId, (data, error) => {
1454
- try {
1455
- if (stub) {
1456
- const displayE = 'Error 400 received on request';
1457
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1458
- } else {
1459
- runCommonAsserts(data, error);
1460
- }
1461
- saveMockData('20130401', 'getHealthCheckLastFailureReason', 'default', data);
1462
- done();
1463
- } catch (err) {
1464
- log.error(`Test Failure: ${err}`);
1465
- done(err);
1466
- }
1467
- });
1468
- } catch (error) {
1469
- log.error(`Adapter Exception: ${error}`);
1470
- done(error);
1471
- }
1472
- } else {
1473
- log.error('getHealthCheckLastFailureReason task is false, skipping test');
1474
- skipCount += 1;
1475
- done();
1476
- }// end if task
1175
+ try {
1176
+ a.getHealthCheckLastFailureReason(HealthCheckId, (data, error) => {
1177
+ try {
1178
+ if (stub) {
1179
+ const displayE = 'Error 400 received on request';
1180
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1181
+ } else {
1182
+ runCommonAsserts(data, error);
1183
+ }
1184
+ saveMockData('20130401', 'getHealthCheckLastFailureReason', 'default', data);
1185
+ done();
1186
+ } catch (err) {
1187
+ log.error(`Test Failure: ${err}`);
1188
+ done(err);
1189
+ }
1190
+ });
1191
+ } catch (error) {
1192
+ log.error(`Adapter Exception: ${error}`);
1193
+ done(error);
1194
+ }
1477
1195
  }).timeout(attemptTimeout);
1478
1196
  });
1479
1197
 
1480
1198
  describe('#getHealthCheckStatus - errors', () => {
1481
1199
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1482
- if (pronghorn.methodsByName.getHealthCheckStatus.task) {
1483
- try {
1484
- a.getHealthCheckStatus(HealthCheckId, (data, error) => {
1485
- try {
1486
- if (stub) {
1487
- const displayE = 'Error 400 received on request';
1488
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1489
- } else {
1490
- runCommonAsserts(data, error);
1491
- }
1492
- saveMockData('20130401', 'getHealthCheckStatus', 'default', data);
1493
- done();
1494
- } catch (err) {
1495
- log.error(`Test Failure: ${err}`);
1496
- done(err);
1497
- }
1498
- });
1499
- } catch (error) {
1500
- log.error(`Adapter Exception: ${error}`);
1501
- done(error);
1502
- }
1503
- } else {
1504
- log.error('getHealthCheckStatus task is false, skipping test');
1505
- skipCount += 1;
1506
- done();
1507
- }// end if task
1200
+ try {
1201
+ a.getHealthCheckStatus(HealthCheckId, (data, error) => {
1202
+ try {
1203
+ if (stub) {
1204
+ const displayE = 'Error 400 received on request';
1205
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1206
+ } else {
1207
+ runCommonAsserts(data, error);
1208
+ }
1209
+ saveMockData('20130401', 'getHealthCheckStatus', 'default', data);
1210
+ done();
1211
+ } catch (err) {
1212
+ log.error(`Test Failure: ${err}`);
1213
+ done(err);
1214
+ }
1215
+ });
1216
+ } catch (error) {
1217
+ log.error(`Adapter Exception: ${error}`);
1218
+ done(error);
1219
+ }
1508
1220
  }).timeout(attemptTimeout);
1509
1221
  });
1510
1222
 
1511
1223
  describe('#getHealthCheckCount - errors', () => {
1512
1224
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1513
- if (pronghorn.methodsByName.getHealthCheckCount.task) {
1514
- try {
1515
- a.getHealthCheckCount((data, error) => {
1516
- try {
1517
- if (stub) {
1518
- const displayE = 'Error 400 received on request';
1519
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1520
- } else {
1521
- runCommonAsserts(data, error);
1522
- }
1523
- saveMockData('20130401', 'getHealthCheckCount', 'default', data);
1524
- done();
1525
- } catch (err) {
1526
- log.error(`Test Failure: ${err}`);
1527
- done(err);
1528
- }
1529
- });
1530
- } catch (error) {
1531
- log.error(`Adapter Exception: ${error}`);
1532
- done(error);
1533
- }
1534
- } else {
1535
- log.error('getHealthCheckCount task is false, skipping test');
1536
- skipCount += 1;
1537
- done();
1538
- }// end if task
1225
+ try {
1226
+ a.getHealthCheckCount((data, error) => {
1227
+ try {
1228
+ if (stub) {
1229
+ const displayE = 'Error 400 received on request';
1230
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1231
+ } else {
1232
+ runCommonAsserts(data, error);
1233
+ }
1234
+ saveMockData('20130401', 'getHealthCheckCount', 'default', data);
1235
+ done();
1236
+ } catch (err) {
1237
+ log.error(`Test Failure: ${err}`);
1238
+ done(err);
1239
+ }
1240
+ });
1241
+ } catch (error) {
1242
+ log.error(`Adapter Exception: ${error}`);
1243
+ done(error);
1244
+ }
1539
1245
  }).timeout(attemptTimeout);
1540
1246
  });
1541
1247
 
1542
1248
  describe('#listHostedZones - errors', () => {
1543
1249
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1544
- if (pronghorn.methodsByName.listHostedZones.task) {
1545
- try {
1546
- a.listHostedZones(null, null, null, null, null, (data, error) => {
1547
- try {
1548
- if (stub) {
1549
- const displayE = 'Error 400 received on request';
1550
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1551
- } else {
1552
- runCommonAsserts(data, error);
1553
- }
1554
- saveMockData('20130401', 'listHostedZones', 'default', data);
1555
- done();
1556
- } catch (err) {
1557
- log.error(`Test Failure: ${err}`);
1558
- done(err);
1559
- }
1560
- });
1561
- } catch (error) {
1562
- log.error(`Adapter Exception: ${error}`);
1563
- done(error);
1564
- }
1565
- } else {
1566
- log.error('listHostedZones task is false, skipping test');
1567
- skipCount += 1;
1568
- done();
1569
- }// end if task
1250
+ try {
1251
+ a.listHostedZones(null, null, null, null, null, (data, error) => {
1252
+ try {
1253
+ if (stub) {
1254
+ const displayE = 'Error 400 received on request';
1255
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1256
+ } else {
1257
+ runCommonAsserts(data, error);
1258
+ }
1259
+ saveMockData('20130401', 'listHostedZones', 'default', data);
1260
+ done();
1261
+ } catch (err) {
1262
+ log.error(`Test Failure: ${err}`);
1263
+ done(err);
1264
+ }
1265
+ });
1266
+ } catch (error) {
1267
+ log.error(`Adapter Exception: ${error}`);
1268
+ done(error);
1269
+ }
1570
1270
  }).timeout(attemptTimeout);
1571
1271
  });
1572
1272
 
1573
1273
  describe('#getHostedZone - errors', () => {
1574
1274
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1575
- if (pronghorn.methodsByName.getHostedZone.task) {
1576
- try {
1577
- a.getHostedZone(Id, (data, error) => {
1578
- try {
1579
- if (stub) {
1580
- const displayE = 'Error 400 received on request';
1581
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1582
- } else {
1583
- runCommonAsserts(data, error);
1584
- }
1585
- saveMockData('20130401', 'getHostedZone', 'default', data);
1586
- done();
1587
- } catch (err) {
1588
- log.error(`Test Failure: ${err}`);
1589
- done(err);
1590
- }
1591
- });
1592
- } catch (error) {
1593
- log.error(`Adapter Exception: ${error}`);
1594
- done(error);
1595
- }
1596
- } else {
1597
- log.error('getHostedZone task is false, skipping test');
1598
- skipCount += 1;
1599
- done();
1600
- }// end if task
1275
+ try {
1276
+ a.getHostedZone(Id, (data, error) => {
1277
+ try {
1278
+ if (stub) {
1279
+ const displayE = 'Error 400 received on request';
1280
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1281
+ } else {
1282
+ runCommonAsserts(data, error);
1283
+ }
1284
+ saveMockData('20130401', 'getHostedZone', 'default', data);
1285
+ done();
1286
+ } catch (err) {
1287
+ log.error(`Test Failure: ${err}`);
1288
+ done(err);
1289
+ }
1290
+ });
1291
+ } catch (error) {
1292
+ log.error(`Adapter Exception: ${error}`);
1293
+ done(error);
1294
+ }
1601
1295
  }).timeout(attemptTimeout);
1602
1296
  });
1603
1297
 
1604
1298
  describe('#listVPCAssociationAuthorizations - errors', () => {
1605
1299
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1606
- if (pronghorn.methodsByName.listVPCAssociationAuthorizations.task) {
1607
- try {
1608
- a.listVPCAssociationAuthorizations(Id, null, null, (data, error) => {
1609
- try {
1610
- if (stub) {
1611
- const displayE = 'Error 400 received on request';
1612
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1613
- } else {
1614
- runCommonAsserts(data, error);
1615
- }
1616
- saveMockData('20130401', 'listVPCAssociationAuthorizations', 'default', data);
1617
- done();
1618
- } catch (err) {
1619
- log.error(`Test Failure: ${err}`);
1620
- done(err);
1621
- }
1622
- });
1623
- } catch (error) {
1624
- log.error(`Adapter Exception: ${error}`);
1625
- done(error);
1626
- }
1627
- } else {
1628
- log.error('listVPCAssociationAuthorizations task is false, skipping test');
1629
- skipCount += 1;
1630
- done();
1631
- }// end if task
1300
+ try {
1301
+ a.listVPCAssociationAuthorizations(Id, null, null, (data, error) => {
1302
+ try {
1303
+ if (stub) {
1304
+ const displayE = 'Error 400 received on request';
1305
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1306
+ } else {
1307
+ runCommonAsserts(data, error);
1308
+ }
1309
+ saveMockData('20130401', 'listVPCAssociationAuthorizations', 'default', data);
1310
+ done();
1311
+ } catch (err) {
1312
+ log.error(`Test Failure: ${err}`);
1313
+ done(err);
1314
+ }
1315
+ });
1316
+ } catch (error) {
1317
+ log.error(`Adapter Exception: ${error}`);
1318
+ done(error);
1319
+ }
1632
1320
  }).timeout(attemptTimeout);
1633
1321
  });
1634
1322
 
1635
1323
  describe('#getDNSSEC - errors', () => {
1636
1324
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1637
- if (pronghorn.methodsByName.getDNSSEC.task) {
1638
- try {
1639
- a.getDNSSEC(Id, (data, error) => {
1640
- try {
1641
- if (stub) {
1642
- const displayE = 'Error 400 received on request';
1643
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1644
- } else {
1645
- runCommonAsserts(data, error);
1646
- }
1647
- saveMockData('20130401', 'getDNSSEC', 'default', data);
1648
- done();
1649
- } catch (err) {
1650
- log.error(`Test Failure: ${err}`);
1651
- done(err);
1652
- }
1653
- });
1654
- } catch (error) {
1655
- log.error(`Adapter Exception: ${error}`);
1656
- done(error);
1657
- }
1658
- } else {
1659
- log.error('getDNSSEC task is false, skipping test');
1660
- skipCount += 1;
1661
- done();
1662
- }// end if task
1325
+ try {
1326
+ a.getDNSSEC(Id, (data, error) => {
1327
+ try {
1328
+ if (stub) {
1329
+ const displayE = 'Error 400 received on request';
1330
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1331
+ } else {
1332
+ runCommonAsserts(data, error);
1333
+ }
1334
+ saveMockData('20130401', 'getDNSSEC', 'default', data);
1335
+ done();
1336
+ } catch (err) {
1337
+ log.error(`Test Failure: ${err}`);
1338
+ done(err);
1339
+ }
1340
+ });
1341
+ } catch (error) {
1342
+ log.error(`Adapter Exception: ${error}`);
1343
+ done(error);
1344
+ }
1663
1345
  }).timeout(attemptTimeout);
1664
1346
  });
1665
1347
 
1666
1348
  describe('#listResourceRecordSets - errors', () => {
1667
1349
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1668
- if (pronghorn.methodsByName.listResourceRecordSets.task) {
1669
- try {
1670
- a.listResourceRecordSets(Id, Name, Type, null, null, null, null, null, null, (data, error) => {
1671
- try {
1672
- if (stub) {
1673
- const displayE = 'Error 400 received on request';
1674
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1675
- } else {
1676
- runCommonAsserts(data, error);
1677
- }
1678
- saveMockData('20130401', 'listResourceRecordSets', 'default', data);
1679
- done();
1680
- } catch (err) {
1681
- log.error(`Test Failure: ${err}`);
1682
- done(err);
1683
- }
1684
- });
1685
- } catch (error) {
1686
- log.error(`Adapter Exception: ${error}`);
1687
- done(error);
1688
- }
1689
- } else {
1690
- log.error('listResourceRecordSets task is false, skipping test');
1691
- skipCount += 1;
1692
- done();
1693
- }// end if task
1350
+ try {
1351
+ a.listResourceRecordSets(Id, Name, Type, null, null, null, null, null, null, (data, error) => {
1352
+ try {
1353
+ if (stub) {
1354
+ const displayE = 'Error 400 received on request';
1355
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1356
+ } else {
1357
+ runCommonAsserts(data, error);
1358
+ }
1359
+ saveMockData('20130401', 'listResourceRecordSets', 'default', data);
1360
+ done();
1361
+ } catch (err) {
1362
+ log.error(`Test Failure: ${err}`);
1363
+ done(err);
1364
+ }
1365
+ });
1366
+ } catch (error) {
1367
+ log.error(`Adapter Exception: ${error}`);
1368
+ done(error);
1369
+ }
1694
1370
  }).timeout(attemptTimeout);
1695
1371
  });
1696
1372
 
1697
1373
  describe('#getHostedZoneCount - errors', () => {
1698
1374
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1699
- if (pronghorn.methodsByName.getHostedZoneCount.task) {
1700
- try {
1701
- a.getHostedZoneCount((data, error) => {
1702
- try {
1703
- if (stub) {
1704
- const displayE = 'Error 400 received on request';
1705
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1706
- } else {
1707
- runCommonAsserts(data, error);
1708
- }
1709
- saveMockData('20130401', 'getHostedZoneCount', 'default', data);
1710
- done();
1711
- } catch (err) {
1712
- log.error(`Test Failure: ${err}`);
1713
- done(err);
1714
- }
1715
- });
1716
- } catch (error) {
1717
- log.error(`Adapter Exception: ${error}`);
1718
- done(error);
1719
- }
1720
- } else {
1721
- log.error('getHostedZoneCount task is false, skipping test');
1722
- skipCount += 1;
1723
- done();
1724
- }// end if task
1375
+ try {
1376
+ a.getHostedZoneCount((data, error) => {
1377
+ try {
1378
+ if (stub) {
1379
+ const displayE = 'Error 400 received on request';
1380
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1381
+ } else {
1382
+ runCommonAsserts(data, error);
1383
+ }
1384
+ saveMockData('20130401', 'getHostedZoneCount', 'default', data);
1385
+ done();
1386
+ } catch (err) {
1387
+ log.error(`Test Failure: ${err}`);
1388
+ done(err);
1389
+ }
1390
+ });
1391
+ } catch (error) {
1392
+ log.error(`Adapter Exception: ${error}`);
1393
+ done(error);
1394
+ }
1725
1395
  }).timeout(attemptTimeout);
1726
1396
  });
1727
1397
 
1728
1398
  describe('#getHostedZoneLimit - errors', () => {
1729
1399
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1730
- if (pronghorn.methodsByName.getHostedZoneLimit.task) {
1731
- try {
1732
- a.getHostedZoneLimit(Type, Id, (data, error) => {
1733
- try {
1734
- if (stub) {
1735
- const displayE = 'Error 400 received on request';
1736
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1737
- } else {
1738
- runCommonAsserts(data, error);
1739
- }
1740
- saveMockData('20130401', 'getHostedZoneLimit', 'default', data);
1741
- done();
1742
- } catch (err) {
1743
- log.error(`Test Failure: ${err}`);
1744
- done(err);
1745
- }
1746
- });
1747
- } catch (error) {
1748
- log.error(`Adapter Exception: ${error}`);
1749
- done(error);
1750
- }
1751
- } else {
1752
- log.error('getHostedZoneLimit task is false, skipping test');
1753
- skipCount += 1;
1754
- done();
1755
- }// end if task
1400
+ try {
1401
+ a.getHostedZoneLimit(Type, Id, (data, error) => {
1402
+ try {
1403
+ if (stub) {
1404
+ const displayE = 'Error 400 received on request';
1405
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1406
+ } else {
1407
+ runCommonAsserts(data, error);
1408
+ }
1409
+ saveMockData('20130401', 'getHostedZoneLimit', 'default', data);
1410
+ done();
1411
+ } catch (err) {
1412
+ log.error(`Test Failure: ${err}`);
1413
+ done(err);
1414
+ }
1415
+ });
1416
+ } catch (error) {
1417
+ log.error(`Adapter Exception: ${error}`);
1418
+ done(error);
1419
+ }
1756
1420
  }).timeout(attemptTimeout);
1757
1421
  });
1758
1422
 
1759
1423
  const Hostedzoneid = 'fakedata';
1760
1424
  describe('#listHostedZonesByName - errors', () => {
1761
1425
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1762
- if (pronghorn.methodsByName.listHostedZonesByName.task) {
1763
- try {
1764
- a.listHostedZonesByName(null, Hostedzoneid, null, (data, error) => {
1765
- try {
1766
- if (stub) {
1767
- const displayE = 'Error 400 received on request';
1768
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1769
- } else {
1770
- runCommonAsserts(data, error);
1771
- }
1772
- saveMockData('20130401', 'listHostedZonesByName', 'default', data);
1773
- done();
1774
- } catch (err) {
1775
- log.error(`Test Failure: ${err}`);
1776
- done(err);
1777
- }
1778
- });
1779
- } catch (error) {
1780
- log.error(`Adapter Exception: ${error}`);
1781
- done(error);
1782
- }
1783
- } else {
1784
- log.error('listHostedZonesByName task is false, skipping test');
1785
- skipCount += 1;
1786
- done();
1787
- }// end if task
1426
+ try {
1427
+ a.listHostedZonesByName(null, Hostedzoneid, null, (data, error) => {
1428
+ try {
1429
+ if (stub) {
1430
+ const displayE = 'Error 400 received on request';
1431
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1432
+ } else {
1433
+ runCommonAsserts(data, error);
1434
+ }
1435
+ saveMockData('20130401', 'listHostedZonesByName', 'default', data);
1436
+ done();
1437
+ } catch (err) {
1438
+ log.error(`Test Failure: ${err}`);
1439
+ done(err);
1440
+ }
1441
+ });
1442
+ } catch (error) {
1443
+ log.error(`Adapter Exception: ${error}`);
1444
+ done(error);
1445
+ }
1788
1446
  }).timeout(attemptTimeout);
1789
1447
  });
1790
1448
 
@@ -1792,156 +1450,126 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
1792
1450
  const Vpcregion = 'fakedata';
1793
1451
  describe('#listHostedZonesByVPC - errors', () => {
1794
1452
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1795
- if (pronghorn.methodsByName.listHostedZonesByVPC.task) {
1796
- try {
1797
- a.listHostedZonesByVPC(Vpcid, Vpcregion, null, null, (data, error) => {
1798
- try {
1799
- if (stub) {
1800
- const displayE = 'Error 400 received on request';
1801
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1802
- } else {
1803
- runCommonAsserts(data, error);
1804
- }
1805
- saveMockData('20130401', 'listHostedZonesByVPC', 'default', data);
1806
- done();
1807
- } catch (err) {
1808
- log.error(`Test Failure: ${err}`);
1809
- done(err);
1810
- }
1811
- });
1812
- } catch (error) {
1813
- log.error(`Adapter Exception: ${error}`);
1814
- done(error);
1815
- }
1816
- } else {
1817
- log.error('listHostedZonesByVPC task is false, skipping test');
1818
- skipCount += 1;
1819
- done();
1820
- }// end if task
1453
+ try {
1454
+ a.listHostedZonesByVPC(Vpcid, Vpcregion, null, null, (data, error) => {
1455
+ try {
1456
+ if (stub) {
1457
+ const displayE = 'Error 400 received on request';
1458
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1459
+ } else {
1460
+ runCommonAsserts(data, error);
1461
+ }
1462
+ saveMockData('20130401', 'listHostedZonesByVPC', 'default', data);
1463
+ done();
1464
+ } catch (err) {
1465
+ log.error(`Test Failure: ${err}`);
1466
+ done(err);
1467
+ }
1468
+ });
1469
+ } catch (error) {
1470
+ log.error(`Adapter Exception: ${error}`);
1471
+ done(error);
1472
+ }
1821
1473
  }).timeout(attemptTimeout);
1822
1474
  });
1823
1475
 
1824
1476
  describe('#listQueryLoggingConfigs - errors', () => {
1825
1477
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1826
- if (pronghorn.methodsByName.listQueryLoggingConfigs.task) {
1827
- try {
1828
- a.listQueryLoggingConfigs(Hostedzoneid, null, null, null, null, (data, error) => {
1829
- try {
1830
- if (stub) {
1831
- const displayE = 'Error 400 received on request';
1832
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1833
- } else {
1834
- runCommonAsserts(data, error);
1835
- }
1836
- saveMockData('20130401', 'listQueryLoggingConfigs', 'default', data);
1837
- done();
1838
- } catch (err) {
1839
- log.error(`Test Failure: ${err}`);
1840
- done(err);
1841
- }
1842
- });
1843
- } catch (error) {
1844
- log.error(`Adapter Exception: ${error}`);
1845
- done(error);
1846
- }
1847
- } else {
1848
- log.error('listQueryLoggingConfigs task is false, skipping test');
1849
- skipCount += 1;
1850
- done();
1851
- }// end if task
1478
+ try {
1479
+ a.listQueryLoggingConfigs(Hostedzoneid, null, null, null, null, (data, error) => {
1480
+ try {
1481
+ if (stub) {
1482
+ const displayE = 'Error 400 received on request';
1483
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1484
+ } else {
1485
+ runCommonAsserts(data, error);
1486
+ }
1487
+ saveMockData('20130401', 'listQueryLoggingConfigs', 'default', data);
1488
+ done();
1489
+ } catch (err) {
1490
+ log.error(`Test Failure: ${err}`);
1491
+ done(err);
1492
+ }
1493
+ });
1494
+ } catch (error) {
1495
+ log.error(`Adapter Exception: ${error}`);
1496
+ done(error);
1497
+ }
1852
1498
  }).timeout(attemptTimeout);
1853
1499
  });
1854
1500
 
1855
1501
  describe('#getQueryLoggingConfig - errors', () => {
1856
1502
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1857
- if (pronghorn.methodsByName.getQueryLoggingConfig.task) {
1858
- try {
1859
- a.getQueryLoggingConfig(Id, (data, error) => {
1860
- try {
1861
- if (stub) {
1862
- const displayE = 'Error 400 received on request';
1863
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1864
- } else {
1865
- runCommonAsserts(data, error);
1866
- }
1867
- saveMockData('20130401', 'getQueryLoggingConfig', 'default', data);
1868
- done();
1869
- } catch (err) {
1870
- log.error(`Test Failure: ${err}`);
1871
- done(err);
1872
- }
1873
- });
1874
- } catch (error) {
1875
- log.error(`Adapter Exception: ${error}`);
1876
- done(error);
1877
- }
1878
- } else {
1879
- log.error('getQueryLoggingConfig task is false, skipping test');
1880
- skipCount += 1;
1881
- done();
1882
- }// end if task
1503
+ try {
1504
+ a.getQueryLoggingConfig(Id, (data, error) => {
1505
+ try {
1506
+ if (stub) {
1507
+ const displayE = 'Error 400 received on request';
1508
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1509
+ } else {
1510
+ runCommonAsserts(data, error);
1511
+ }
1512
+ saveMockData('20130401', 'getQueryLoggingConfig', 'default', data);
1513
+ done();
1514
+ } catch (err) {
1515
+ log.error(`Test Failure: ${err}`);
1516
+ done(err);
1517
+ }
1518
+ });
1519
+ } catch (error) {
1520
+ log.error(`Adapter Exception: ${error}`);
1521
+ done(error);
1522
+ }
1883
1523
  }).timeout(attemptTimeout);
1884
1524
  });
1885
1525
 
1886
1526
  describe('#getReusableDelegationSetLimit - errors', () => {
1887
1527
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1888
- if (pronghorn.methodsByName.getReusableDelegationSetLimit.task) {
1889
- try {
1890
- a.getReusableDelegationSetLimit(Type, Id, (data, error) => {
1891
- try {
1892
- if (stub) {
1893
- const displayE = 'Error 400 received on request';
1894
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1895
- } else {
1896
- runCommonAsserts(data, error);
1897
- }
1898
- saveMockData('20130401', 'getReusableDelegationSetLimit', 'default', data);
1899
- done();
1900
- } catch (err) {
1901
- log.error(`Test Failure: ${err}`);
1902
- done(err);
1903
- }
1904
- });
1905
- } catch (error) {
1906
- log.error(`Adapter Exception: ${error}`);
1907
- done(error);
1908
- }
1909
- } else {
1910
- log.error('getReusableDelegationSetLimit task is false, skipping test');
1911
- skipCount += 1;
1912
- done();
1913
- }// end if task
1528
+ try {
1529
+ a.getReusableDelegationSetLimit(Type, Id, (data, error) => {
1530
+ try {
1531
+ if (stub) {
1532
+ const displayE = 'Error 400 received on request';
1533
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1534
+ } else {
1535
+ runCommonAsserts(data, error);
1536
+ }
1537
+ saveMockData('20130401', 'getReusableDelegationSetLimit', 'default', data);
1538
+ done();
1539
+ } catch (err) {
1540
+ log.error(`Test Failure: ${err}`);
1541
+ done(err);
1542
+ }
1543
+ });
1544
+ } catch (error) {
1545
+ log.error(`Adapter Exception: ${error}`);
1546
+ done(error);
1547
+ }
1914
1548
  }).timeout(attemptTimeout);
1915
1549
  });
1916
1550
 
1917
1551
  describe('#listTagsForResource - errors', () => {
1918
1552
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1919
- if (pronghorn.methodsByName.listTagsForResource.task) {
1920
- try {
1921
- a.listTagsForResource(ResourceType, ResourceId, (data, error) => {
1922
- try {
1923
- if (stub) {
1924
- const displayE = 'Error 400 received on request';
1925
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1926
- } else {
1927
- runCommonAsserts(data, error);
1928
- }
1929
- saveMockData('20130401', 'listTagsForResource', 'default', data);
1930
- done();
1931
- } catch (err) {
1932
- log.error(`Test Failure: ${err}`);
1933
- done(err);
1934
- }
1935
- });
1936
- } catch (error) {
1937
- log.error(`Adapter Exception: ${error}`);
1938
- done(error);
1939
- }
1940
- } else {
1941
- log.error('listTagsForResource task is false, skipping test');
1942
- skipCount += 1;
1943
- done();
1944
- }// end if task
1553
+ try {
1554
+ a.listTagsForResource(ResourceType, ResourceId, (data, error) => {
1555
+ try {
1556
+ if (stub) {
1557
+ const displayE = 'Error 400 received on request';
1558
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1559
+ } else {
1560
+ runCommonAsserts(data, error);
1561
+ }
1562
+ saveMockData('20130401', 'listTagsForResource', 'default', data);
1563
+ done();
1564
+ } catch (err) {
1565
+ log.error(`Test Failure: ${err}`);
1566
+ done(err);
1567
+ }
1568
+ });
1569
+ } catch (error) {
1570
+ log.error(`Adapter Exception: ${error}`);
1571
+ done(error);
1572
+ }
1945
1573
  }).timeout(attemptTimeout);
1946
1574
  });
1947
1575
 
@@ -1949,505 +1577,402 @@ describe('[integration] Amazon_route53 Adapter Test', () => {
1949
1577
  const Recordtype = 'fakedata';
1950
1578
  describe('#testDNSAnswer - errors', () => {
1951
1579
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1952
- if (pronghorn.methodsByName.testDNSAnswer.task) {
1953
- try {
1954
- a.testDNSAnswer(Hostedzoneid, Recordname, Recordtype, null, null, null, (data, error) => {
1955
- try {
1956
- if (stub) {
1957
- const displayE = 'Error 400 received on request';
1958
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1959
- } else {
1960
- runCommonAsserts(data, error);
1961
- }
1962
- saveMockData('20130401', 'testDNSAnswer', 'default', data);
1963
- done();
1964
- } catch (err) {
1965
- log.error(`Test Failure: ${err}`);
1966
- done(err);
1967
- }
1968
- });
1969
- } catch (error) {
1970
- log.error(`Adapter Exception: ${error}`);
1971
- done(error);
1972
- }
1973
- } else {
1974
- log.error('testDNSAnswer task is false, skipping test');
1975
- skipCount += 1;
1976
- done();
1977
- }// end if task
1580
+ try {
1581
+ a.testDNSAnswer(Hostedzoneid, Recordname, Recordtype, null, null, null, (data, error) => {
1582
+ try {
1583
+ if (stub) {
1584
+ const displayE = 'Error 400 received on request';
1585
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1586
+ } else {
1587
+ runCommonAsserts(data, error);
1588
+ }
1589
+ saveMockData('20130401', 'testDNSAnswer', 'default', data);
1590
+ done();
1591
+ } catch (err) {
1592
+ log.error(`Test Failure: ${err}`);
1593
+ done(err);
1594
+ }
1595
+ });
1596
+ } catch (error) {
1597
+ log.error(`Adapter Exception: ${error}`);
1598
+ done(error);
1599
+ }
1978
1600
  }).timeout(attemptTimeout);
1979
1601
  });
1980
1602
 
1981
1603
  describe('#listTrafficPolicies - errors', () => {
1982
1604
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
1983
- if (pronghorn.methodsByName.listTrafficPolicies.task) {
1984
- try {
1985
- a.listTrafficPolicies(null, null, (data, error) => {
1986
- try {
1987
- if (stub) {
1988
- const displayE = 'Error 400 received on request';
1989
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1990
- } else {
1991
- runCommonAsserts(data, error);
1992
- }
1993
- saveMockData('20130401', 'listTrafficPolicies', 'default', data);
1994
- done();
1995
- } catch (err) {
1996
- log.error(`Test Failure: ${err}`);
1997
- done(err);
1998
- }
1999
- });
2000
- } catch (error) {
2001
- log.error(`Adapter Exception: ${error}`);
2002
- done(error);
2003
- }
2004
- } else {
2005
- log.error('listTrafficPolicies task is false, skipping test');
2006
- skipCount += 1;
2007
- done();
2008
- }// end if task
1605
+ try {
1606
+ a.listTrafficPolicies(null, null, (data, error) => {
1607
+ try {
1608
+ if (stub) {
1609
+ const displayE = 'Error 400 received on request';
1610
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1611
+ } else {
1612
+ runCommonAsserts(data, error);
1613
+ }
1614
+ saveMockData('20130401', 'listTrafficPolicies', 'default', data);
1615
+ done();
1616
+ } catch (err) {
1617
+ log.error(`Test Failure: ${err}`);
1618
+ done(err);
1619
+ }
1620
+ });
1621
+ } catch (error) {
1622
+ log.error(`Adapter Exception: ${error}`);
1623
+ done(error);
1624
+ }
2009
1625
  }).timeout(attemptTimeout);
2010
1626
  });
2011
1627
 
2012
1628
  describe('#listTrafficPolicyVersions - errors', () => {
2013
1629
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2014
- if (pronghorn.methodsByName.listTrafficPolicyVersions.task) {
2015
- try {
2016
- a.listTrafficPolicyVersions(Id, null, null, (data, error) => {
2017
- try {
2018
- if (stub) {
2019
- const displayE = 'Error 400 received on request';
2020
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2021
- } else {
2022
- runCommonAsserts(data, error);
2023
- }
2024
- saveMockData('20130401', 'listTrafficPolicyVersions', 'default', data);
2025
- done();
2026
- } catch (err) {
2027
- log.error(`Test Failure: ${err}`);
2028
- done(err);
2029
- }
2030
- });
2031
- } catch (error) {
2032
- log.error(`Adapter Exception: ${error}`);
2033
- done(error);
2034
- }
2035
- } else {
2036
- log.error('listTrafficPolicyVersions task is false, skipping test');
2037
- skipCount += 1;
2038
- done();
2039
- }// end if task
1630
+ try {
1631
+ a.listTrafficPolicyVersions(Id, null, null, (data, error) => {
1632
+ try {
1633
+ if (stub) {
1634
+ const displayE = 'Error 400 received on request';
1635
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1636
+ } else {
1637
+ runCommonAsserts(data, error);
1638
+ }
1639
+ saveMockData('20130401', 'listTrafficPolicyVersions', 'default', data);
1640
+ done();
1641
+ } catch (err) {
1642
+ log.error(`Test Failure: ${err}`);
1643
+ done(err);
1644
+ }
1645
+ });
1646
+ } catch (error) {
1647
+ log.error(`Adapter Exception: ${error}`);
1648
+ done(error);
1649
+ }
2040
1650
  }).timeout(attemptTimeout);
2041
1651
  });
2042
1652
 
2043
1653
  describe('#getTrafficPolicy - errors', () => {
2044
1654
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2045
- if (pronghorn.methodsByName.getTrafficPolicy.task) {
2046
- try {
2047
- a.getTrafficPolicy(Id, Version, (data, error) => {
2048
- try {
2049
- if (stub) {
2050
- const displayE = 'Error 400 received on request';
2051
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2052
- } else {
2053
- runCommonAsserts(data, error);
2054
- }
2055
- saveMockData('20130401', 'getTrafficPolicy', 'default', data);
2056
- done();
2057
- } catch (err) {
2058
- log.error(`Test Failure: ${err}`);
2059
- done(err);
2060
- }
2061
- });
2062
- } catch (error) {
2063
- log.error(`Adapter Exception: ${error}`);
2064
- done(error);
2065
- }
2066
- } else {
2067
- log.error('getTrafficPolicy task is false, skipping test');
2068
- skipCount += 1;
2069
- done();
2070
- }// end if task
1655
+ try {
1656
+ a.getTrafficPolicy(Id, Version, (data, error) => {
1657
+ try {
1658
+ if (stub) {
1659
+ const displayE = 'Error 400 received on request';
1660
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1661
+ } else {
1662
+ runCommonAsserts(data, error);
1663
+ }
1664
+ saveMockData('20130401', 'getTrafficPolicy', 'default', data);
1665
+ done();
1666
+ } catch (err) {
1667
+ log.error(`Test Failure: ${err}`);
1668
+ done(err);
1669
+ }
1670
+ });
1671
+ } catch (error) {
1672
+ log.error(`Adapter Exception: ${error}`);
1673
+ done(error);
1674
+ }
2071
1675
  }).timeout(attemptTimeout);
2072
1676
  });
2073
1677
 
2074
1678
  describe('#getTrafficPolicyInstance - errors', () => {
2075
1679
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2076
- if (pronghorn.methodsByName.getTrafficPolicyInstance.task) {
2077
- try {
2078
- a.getTrafficPolicyInstance(Id, (data, error) => {
2079
- try {
2080
- if (stub) {
2081
- const displayE = 'Error 400 received on request';
2082
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2083
- } else {
2084
- runCommonAsserts(data, error);
2085
- }
2086
- saveMockData('20130401', 'getTrafficPolicyInstance', 'default', data);
2087
- done();
2088
- } catch (err) {
2089
- log.error(`Test Failure: ${err}`);
2090
- done(err);
2091
- }
2092
- });
2093
- } catch (error) {
2094
- log.error(`Adapter Exception: ${error}`);
2095
- done(error);
2096
- }
2097
- } else {
2098
- log.error('getTrafficPolicyInstance task is false, skipping test');
2099
- skipCount += 1;
2100
- done();
2101
- }// end if task
1680
+ try {
1681
+ a.getTrafficPolicyInstance(Id, (data, error) => {
1682
+ try {
1683
+ if (stub) {
1684
+ const displayE = 'Error 400 received on request';
1685
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1686
+ } else {
1687
+ runCommonAsserts(data, error);
1688
+ }
1689
+ saveMockData('20130401', 'getTrafficPolicyInstance', 'default', data);
1690
+ done();
1691
+ } catch (err) {
1692
+ log.error(`Test Failure: ${err}`);
1693
+ done(err);
1694
+ }
1695
+ });
1696
+ } catch (error) {
1697
+ log.error(`Adapter Exception: ${error}`);
1698
+ done(error);
1699
+ }
2102
1700
  }).timeout(attemptTimeout);
2103
1701
  });
2104
1702
 
2105
1703
  describe('#getTrafficPolicyInstanceCount - errors', () => {
2106
1704
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2107
- if (pronghorn.methodsByName.getTrafficPolicyInstanceCount.task) {
2108
- try {
2109
- a.getTrafficPolicyInstanceCount((data, error) => {
2110
- try {
2111
- if (stub) {
2112
- const displayE = 'Error 400 received on request';
2113
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2114
- } else {
2115
- runCommonAsserts(data, error);
2116
- }
2117
- saveMockData('20130401', 'getTrafficPolicyInstanceCount', 'default', data);
2118
- done();
2119
- } catch (err) {
2120
- log.error(`Test Failure: ${err}`);
2121
- done(err);
2122
- }
2123
- });
2124
- } catch (error) {
2125
- log.error(`Adapter Exception: ${error}`);
2126
- done(error);
2127
- }
2128
- } else {
2129
- log.error('getTrafficPolicyInstanceCount task is false, skipping test');
2130
- skipCount += 1;
2131
- done();
2132
- }// end if task
1705
+ try {
1706
+ a.getTrafficPolicyInstanceCount((data, error) => {
1707
+ try {
1708
+ if (stub) {
1709
+ const displayE = 'Error 400 received on request';
1710
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1711
+ } else {
1712
+ runCommonAsserts(data, error);
1713
+ }
1714
+ saveMockData('20130401', 'getTrafficPolicyInstanceCount', 'default', data);
1715
+ done();
1716
+ } catch (err) {
1717
+ log.error(`Test Failure: ${err}`);
1718
+ done(err);
1719
+ }
1720
+ });
1721
+ } catch (error) {
1722
+ log.error(`Adapter Exception: ${error}`);
1723
+ done(error);
1724
+ }
2133
1725
  }).timeout(attemptTimeout);
2134
1726
  });
2135
1727
 
2136
1728
  describe('#listTrafficPolicyInstances - errors', () => {
2137
1729
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2138
- if (pronghorn.methodsByName.listTrafficPolicyInstances.task) {
2139
- try {
2140
- a.listTrafficPolicyInstances(Hostedzoneid, null, null, null, (data, error) => {
2141
- try {
2142
- if (stub) {
2143
- const displayE = 'Error 400 received on request';
2144
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2145
- } else {
2146
- runCommonAsserts(data, error);
2147
- }
2148
- saveMockData('20130401', 'listTrafficPolicyInstances', 'default', data);
2149
- done();
2150
- } catch (err) {
2151
- log.error(`Test Failure: ${err}`);
2152
- done(err);
2153
- }
2154
- });
2155
- } catch (error) {
2156
- log.error(`Adapter Exception: ${error}`);
2157
- done(error);
2158
- }
2159
- } else {
2160
- log.error('listTrafficPolicyInstances task is false, skipping test');
2161
- skipCount += 1;
2162
- done();
2163
- }// end if task
1730
+ try {
1731
+ a.listTrafficPolicyInstances(Hostedzoneid, null, null, null, (data, error) => {
1732
+ try {
1733
+ if (stub) {
1734
+ const displayE = 'Error 400 received on request';
1735
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1736
+ } else {
1737
+ runCommonAsserts(data, error);
1738
+ }
1739
+ saveMockData('20130401', 'listTrafficPolicyInstances', 'default', data);
1740
+ done();
1741
+ } catch (err) {
1742
+ log.error(`Test Failure: ${err}`);
1743
+ done(err);
1744
+ }
1745
+ });
1746
+ } catch (error) {
1747
+ log.error(`Adapter Exception: ${error}`);
1748
+ done(error);
1749
+ }
2164
1750
  }).timeout(attemptTimeout);
2165
1751
  });
2166
1752
 
2167
1753
  describe('#listTrafficPolicyInstancesByHostedZone - errors', () => {
2168
1754
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2169
- if (pronghorn.methodsByName.listTrafficPolicyInstancesByHostedZone.task) {
2170
- try {
2171
- a.listTrafficPolicyInstancesByHostedZone(Id, null, null, null, (data, error) => {
2172
- try {
2173
- if (stub) {
2174
- const displayE = 'Error 400 received on request';
2175
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2176
- } else {
2177
- runCommonAsserts(data, error);
2178
- }
2179
- saveMockData('20130401', 'listTrafficPolicyInstancesByHostedZone', 'default', data);
2180
- done();
2181
- } catch (err) {
2182
- log.error(`Test Failure: ${err}`);
2183
- done(err);
2184
- }
2185
- });
2186
- } catch (error) {
2187
- log.error(`Adapter Exception: ${error}`);
2188
- done(error);
2189
- }
2190
- } else {
2191
- log.error('listTrafficPolicyInstancesByHostedZone task is false, skipping test');
2192
- skipCount += 1;
2193
- done();
2194
- }// end if task
1755
+ try {
1756
+ a.listTrafficPolicyInstancesByHostedZone(Id, null, null, null, (data, error) => {
1757
+ try {
1758
+ if (stub) {
1759
+ const displayE = 'Error 400 received on request';
1760
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1761
+ } else {
1762
+ runCommonAsserts(data, error);
1763
+ }
1764
+ saveMockData('20130401', 'listTrafficPolicyInstancesByHostedZone', 'default', data);
1765
+ done();
1766
+ } catch (err) {
1767
+ log.error(`Test Failure: ${err}`);
1768
+ done(err);
1769
+ }
1770
+ });
1771
+ } catch (error) {
1772
+ log.error(`Adapter Exception: ${error}`);
1773
+ done(error);
1774
+ }
2195
1775
  }).timeout(attemptTimeout);
2196
1776
  });
2197
1777
 
2198
1778
  describe('#listTrafficPolicyInstancesByPolicy - errors', () => {
2199
1779
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2200
- if (pronghorn.methodsByName.listTrafficPolicyInstancesByPolicy.task) {
2201
- try {
2202
- a.listTrafficPolicyInstancesByPolicy(Id, Version, Hostedzoneid, null, null, null, (data, error) => {
2203
- try {
2204
- if (stub) {
2205
- const displayE = 'Error 400 received on request';
2206
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2207
- } else {
2208
- runCommonAsserts(data, error);
2209
- }
2210
- saveMockData('20130401', 'listTrafficPolicyInstancesByPolicy', 'default', data);
2211
- done();
2212
- } catch (err) {
2213
- log.error(`Test Failure: ${err}`);
2214
- done(err);
2215
- }
2216
- });
2217
- } catch (error) {
2218
- log.error(`Adapter Exception: ${error}`);
2219
- done(error);
2220
- }
2221
- } else {
2222
- log.error('listTrafficPolicyInstancesByPolicy task is false, skipping test');
2223
- skipCount += 1;
2224
- done();
2225
- }// end if task
1780
+ try {
1781
+ a.listTrafficPolicyInstancesByPolicy(Id, Version, Hostedzoneid, null, null, null, (data, error) => {
1782
+ try {
1783
+ if (stub) {
1784
+ const displayE = 'Error 400 received on request';
1785
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1786
+ } else {
1787
+ runCommonAsserts(data, error);
1788
+ }
1789
+ saveMockData('20130401', 'listTrafficPolicyInstancesByPolicy', 'default', data);
1790
+ done();
1791
+ } catch (err) {
1792
+ log.error(`Test Failure: ${err}`);
1793
+ done(err);
1794
+ }
1795
+ });
1796
+ } catch (error) {
1797
+ log.error(`Adapter Exception: ${error}`);
1798
+ done(error);
1799
+ }
2226
1800
  }).timeout(attemptTimeout);
2227
1801
  });
2228
1802
 
2229
1803
  describe('#deleteReusableDelegationSet - errors', () => {
2230
1804
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2231
- if (pronghorn.methodsByName.deleteReusableDelegationSet.task) {
2232
- try {
2233
- a.deleteReusableDelegationSet(Id, (data, error) => {
2234
- try {
2235
- if (stub) {
2236
- const displayE = 'Error 400 received on request';
2237
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2238
- } else {
2239
- runCommonAsserts(data, error);
2240
- }
2241
- saveMockData('20130401', 'deleteReusableDelegationSet', 'default', data);
2242
- done();
2243
- } catch (err) {
2244
- log.error(`Test Failure: ${err}`);
2245
- done(err);
2246
- }
2247
- });
2248
- } catch (error) {
2249
- log.error(`Adapter Exception: ${error}`);
2250
- done(error);
2251
- }
2252
- } else {
2253
- log.error('deleteReusableDelegationSet task is false, skipping test');
2254
- skipCount += 1;
2255
- done();
2256
- }// end if task
1805
+ try {
1806
+ a.deleteReusableDelegationSet(Id, (data, error) => {
1807
+ try {
1808
+ if (stub) {
1809
+ const displayE = 'Error 400 received on request';
1810
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1811
+ } else {
1812
+ runCommonAsserts(data, error);
1813
+ }
1814
+ saveMockData('20130401', 'deleteReusableDelegationSet', 'default', data);
1815
+ done();
1816
+ } catch (err) {
1817
+ log.error(`Test Failure: ${err}`);
1818
+ done(err);
1819
+ }
1820
+ });
1821
+ } catch (error) {
1822
+ log.error(`Adapter Exception: ${error}`);
1823
+ done(error);
1824
+ }
2257
1825
  }).timeout(attemptTimeout);
2258
1826
  });
2259
1827
 
2260
1828
  describe('#deleteHealthCheck - errors', () => {
2261
1829
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2262
- if (pronghorn.methodsByName.deleteHealthCheck.task) {
2263
- try {
2264
- a.deleteHealthCheck(HealthCheckId, (data, error) => {
2265
- try {
2266
- if (stub) {
2267
- const displayE = 'Error 400 received on request';
2268
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2269
- } else {
2270
- runCommonAsserts(data, error);
2271
- }
2272
- saveMockData('20130401', 'deleteHealthCheck', 'default', data);
2273
- done();
2274
- } catch (err) {
2275
- log.error(`Test Failure: ${err}`);
2276
- done(err);
2277
- }
2278
- });
2279
- } catch (error) {
2280
- log.error(`Adapter Exception: ${error}`);
2281
- done(error);
2282
- }
2283
- } else {
2284
- log.error('deleteHealthCheck task is false, skipping test');
2285
- skipCount += 1;
2286
- done();
2287
- }// end if task
1830
+ try {
1831
+ a.deleteHealthCheck(HealthCheckId, (data, error) => {
1832
+ try {
1833
+ if (stub) {
1834
+ const displayE = 'Error 400 received on request';
1835
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1836
+ } else {
1837
+ runCommonAsserts(data, error);
1838
+ }
1839
+ saveMockData('20130401', 'deleteHealthCheck', 'default', data);
1840
+ done();
1841
+ } catch (err) {
1842
+ log.error(`Test Failure: ${err}`);
1843
+ done(err);
1844
+ }
1845
+ });
1846
+ } catch (error) {
1847
+ log.error(`Adapter Exception: ${error}`);
1848
+ done(error);
1849
+ }
2288
1850
  }).timeout(attemptTimeout);
2289
1851
  });
2290
1852
 
2291
1853
  describe('#deleteHostedZone - errors', () => {
2292
1854
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2293
- if (pronghorn.methodsByName.deleteHostedZone.task) {
2294
- try {
2295
- a.deleteHostedZone(Id, (data, error) => {
2296
- try {
2297
- if (stub) {
2298
- const displayE = 'Error 400 received on request';
2299
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2300
- } else {
2301
- runCommonAsserts(data, error);
2302
- }
2303
- saveMockData('20130401', 'deleteHostedZone', 'default', data);
2304
- done();
2305
- } catch (err) {
2306
- log.error(`Test Failure: ${err}`);
2307
- done(err);
2308
- }
2309
- });
2310
- } catch (error) {
2311
- log.error(`Adapter Exception: ${error}`);
2312
- done(error);
2313
- }
2314
- } else {
2315
- log.error('deleteHostedZone task is false, skipping test');
2316
- skipCount += 1;
2317
- done();
2318
- }// end if task
1855
+ try {
1856
+ a.deleteHostedZone(Id, (data, error) => {
1857
+ try {
1858
+ if (stub) {
1859
+ const displayE = 'Error 400 received on request';
1860
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1861
+ } else {
1862
+ runCommonAsserts(data, error);
1863
+ }
1864
+ saveMockData('20130401', 'deleteHostedZone', 'default', data);
1865
+ done();
1866
+ } catch (err) {
1867
+ log.error(`Test Failure: ${err}`);
1868
+ done(err);
1869
+ }
1870
+ });
1871
+ } catch (error) {
1872
+ log.error(`Adapter Exception: ${error}`);
1873
+ done(error);
1874
+ }
2319
1875
  }).timeout(attemptTimeout);
2320
1876
  });
2321
1877
 
2322
1878
  describe('#deleteKeySigningKey - errors', () => {
2323
1879
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2324
- if (pronghorn.methodsByName.deleteKeySigningKey.task) {
2325
- try {
2326
- a.deleteKeySigningKey(HostedZoneId, Name, (data, error) => {
2327
- try {
2328
- if (stub) {
2329
- const displayE = 'Error 400 received on request';
2330
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2331
- } else {
2332
- runCommonAsserts(data, error);
2333
- }
2334
- saveMockData('20130401', 'deleteKeySigningKey', 'default', data);
2335
- done();
2336
- } catch (err) {
2337
- log.error(`Test Failure: ${err}`);
2338
- done(err);
2339
- }
2340
- });
2341
- } catch (error) {
2342
- log.error(`Adapter Exception: ${error}`);
2343
- done(error);
2344
- }
2345
- } else {
2346
- log.error('deleteKeySigningKey task is false, skipping test');
2347
- skipCount += 1;
2348
- done();
2349
- }// end if task
1880
+ try {
1881
+ a.deleteKeySigningKey(HostedZoneId, Name, (data, error) => {
1882
+ try {
1883
+ if (stub) {
1884
+ const displayE = 'Error 400 received on request';
1885
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1886
+ } else {
1887
+ runCommonAsserts(data, error);
1888
+ }
1889
+ saveMockData('20130401', 'deleteKeySigningKey', 'default', data);
1890
+ done();
1891
+ } catch (err) {
1892
+ log.error(`Test Failure: ${err}`);
1893
+ done(err);
1894
+ }
1895
+ });
1896
+ } catch (error) {
1897
+ log.error(`Adapter Exception: ${error}`);
1898
+ done(error);
1899
+ }
2350
1900
  }).timeout(attemptTimeout);
2351
1901
  });
2352
1902
 
2353
1903
  describe('#deleteQueryLoggingConfig - errors', () => {
2354
1904
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2355
- if (pronghorn.methodsByName.deleteQueryLoggingConfig.task) {
2356
- try {
2357
- a.deleteQueryLoggingConfig(Id, (data, error) => {
2358
- try {
2359
- if (stub) {
2360
- const displayE = 'Error 400 received on request';
2361
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2362
- } else {
2363
- runCommonAsserts(data, error);
2364
- }
2365
- saveMockData('20130401', 'deleteQueryLoggingConfig', 'default', data);
2366
- done();
2367
- } catch (err) {
2368
- log.error(`Test Failure: ${err}`);
2369
- done(err);
2370
- }
2371
- });
2372
- } catch (error) {
2373
- log.error(`Adapter Exception: ${error}`);
2374
- done(error);
2375
- }
2376
- } else {
2377
- log.error('deleteQueryLoggingConfig task is false, skipping test');
2378
- skipCount += 1;
2379
- done();
2380
- }// end if task
1905
+ try {
1906
+ a.deleteQueryLoggingConfig(Id, (data, error) => {
1907
+ try {
1908
+ if (stub) {
1909
+ const displayE = 'Error 400 received on request';
1910
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1911
+ } else {
1912
+ runCommonAsserts(data, error);
1913
+ }
1914
+ saveMockData('20130401', 'deleteQueryLoggingConfig', 'default', data);
1915
+ done();
1916
+ } catch (err) {
1917
+ log.error(`Test Failure: ${err}`);
1918
+ done(err);
1919
+ }
1920
+ });
1921
+ } catch (error) {
1922
+ log.error(`Adapter Exception: ${error}`);
1923
+ done(error);
1924
+ }
2381
1925
  }).timeout(attemptTimeout);
2382
1926
  });
2383
1927
 
2384
1928
  describe('#deleteTrafficPolicy - errors', () => {
2385
1929
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2386
- if (pronghorn.methodsByName.deleteTrafficPolicy.task) {
2387
- try {
2388
- a.deleteTrafficPolicy(Id, Version, (data, error) => {
2389
- try {
2390
- if (stub) {
2391
- const displayE = 'Error 400 received on request';
2392
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2393
- } else {
2394
- runCommonAsserts(data, error);
2395
- }
2396
- saveMockData('20130401', 'deleteTrafficPolicy', 'default', data);
2397
- done();
2398
- } catch (err) {
2399
- log.error(`Test Failure: ${err}`);
2400
- done(err);
2401
- }
2402
- });
2403
- } catch (error) {
2404
- log.error(`Adapter Exception: ${error}`);
2405
- done(error);
2406
- }
2407
- } else {
2408
- log.error('deleteTrafficPolicy task is false, skipping test');
2409
- skipCount += 1;
2410
- done();
2411
- }// end if task
1930
+ try {
1931
+ a.deleteTrafficPolicy(Id, Version, (data, error) => {
1932
+ try {
1933
+ if (stub) {
1934
+ const displayE = 'Error 400 received on request';
1935
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1936
+ } else {
1937
+ runCommonAsserts(data, error);
1938
+ }
1939
+ saveMockData('20130401', 'deleteTrafficPolicy', 'default', data);
1940
+ done();
1941
+ } catch (err) {
1942
+ log.error(`Test Failure: ${err}`);
1943
+ done(err);
1944
+ }
1945
+ });
1946
+ } catch (error) {
1947
+ log.error(`Adapter Exception: ${error}`);
1948
+ done(error);
1949
+ }
2412
1950
  }).timeout(attemptTimeout);
2413
1951
  });
2414
1952
 
2415
1953
  describe('#deleteTrafficPolicyInstance - errors', () => {
2416
1954
  it('should work if integrated but since no mockdata should error when run standalone', (done) => {
2417
- if (pronghorn.methodsByName.deleteTrafficPolicyInstance.task) {
2418
- try {
2419
- a.deleteTrafficPolicyInstance(Id, (data, error) => {
2420
- try {
2421
- if (stub) {
2422
- const displayE = 'Error 400 received on request';
2423
- runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
2424
- } else {
2425
- runCommonAsserts(data, error);
2426
- }
2427
- saveMockData('20130401', 'deleteTrafficPolicyInstance', 'default', data);
2428
- done();
2429
- } catch (err) {
2430
- log.error(`Test Failure: ${err}`);
2431
- done(err);
2432
- }
2433
- });
2434
- } catch (error) {
2435
- log.error(`Adapter Exception: ${error}`);
2436
- done(error);
2437
- }
2438
- } else {
2439
- log.error('deleteTrafficPolicyInstance task is false, skipping test');
2440
- skipCount += 1;
2441
- done();
2442
- }// end if task
1955
+ try {
1956
+ a.deleteTrafficPolicyInstance(Id, (data, error) => {
1957
+ try {
1958
+ if (stub) {
1959
+ const displayE = 'Error 400 received on request';
1960
+ runErrorAsserts(data, error, 'AD.500', 'Test-amazon_route53-connectorRest-handleEndResponse', displayE);
1961
+ } else {
1962
+ runCommonAsserts(data, error);
1963
+ }
1964
+ saveMockData('20130401', 'deleteTrafficPolicyInstance', 'default', data);
1965
+ done();
1966
+ } catch (err) {
1967
+ log.error(`Test Failure: ${err}`);
1968
+ done(err);
1969
+ }
1970
+ });
1971
+ } catch (error) {
1972
+ log.error(`Adapter Exception: ${error}`);
1973
+ done(error);
1974
+ }
2443
1975
  }).timeout(attemptTimeout);
2444
1976
  });
2445
-
2446
- describe('#Skipped test count', () => {
2447
- it('count skipped tests', (done) => {
2448
- console.log(`skipped ${skipCount} tests because \x1b[33mtask: false\x1b[0m`);
2449
- done();
2450
- });
2451
- });
2452
1977
  });
2453
1978
  });