@zohodesk/testinglibrary 0.1.8-exp-bdd-v3 → 0.1.8-exp-bdd-v4

package/build/bdd-framework/stepDefinitions/decorators/steps.js

@@ -0,0 +1,99 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.appendDecoratorSteps = appendDecoratorSteps;
+exports.createStepDecorator = createStepDecorator;
+exports.linkStepsWithPomNode = linkStepsWithPomNode;
+var _bddFixtures = require("../../run/bddFixtures");
+var _buildStepDefinition = require("../../cucumber/buildStepDefinition");
+var _defineStep = require("../defineStep");
+/**
+ * Define steps via decorators.
+ */
+
+// initially we sotre step data inside method,
+// and then extract it in @Fixture decorator call
+const decoratedStepSymbol = Symbol('decoratedStep');
+// global list of all decorator steps
+const decoratedSteps = new Set();
+/**
+ * Creates @Given, @When, @Then decorators.
+ */
+function createStepDecorator(keyword) {
+  return pattern => {
+    // context parameter is required for decorator by TS even though it's not used
+    // eslint-disable-next-line no-unused-vars
+    return (method, _context) => {
+      saveStepConfigToMethod(method, {
+        keyword,
+        pattern,
+        fn: method,
+        hasCustomTest: true
+      });
+    };
+  };
+}
+function linkStepsWithPomNode(Ctor, pomNode) {
+  if (!(Ctor !== null && Ctor !== void 0 && Ctor.prototype)) {
+    return;
+  }
+  const propertyDescriptors = Object.getOwnPropertyDescriptors(Ctor.prototype);
+  return Object.values(propertyDescriptors).forEach(descriptor => {
+    const stepConfig = getStepConfigFromMethod(descriptor);
+    if (!stepConfig) {
+      return;
+    }
+    stepConfig.pomNode = pomNode;
+    decoratedSteps.add(stepConfig);
+  });
+}
+/**
+ * Append decorator steps to Cucumber's supportCodeLibrary.
+ */
+function appendDecoratorSteps(supportCodeLibrary) {
+  decoratedSteps.forEach(stepConfig => {
+    const {
+      keyword,
+      pattern,
+      fn
+    } = stepConfig;
+    stepConfig.fn = (fixturesArg, ...args) => {
+      const fixture = getFirstNonAutoInjectFixture(fixturesArg, stepConfig);
+      return fn.call(fixture, ...args);
+    };
+    const code = (0, _defineStep.buildCucumberStepCode)(stepConfig);
+    const stepDefinition = (0, _buildStepDefinition.buildStepDefinition)({
+      keyword,
+      pattern,
+      code,
+      line: 0,
+      // not used in playwright-bdd
+      options: {},
+      // not used in playwright-bdd
+      uri: '' // not used in playwright-bdd
+    }, supportCodeLibrary);
+    supportCodeLibrary.stepDefinitions.push(stepDefinition);
+  });
+  decoratedSteps.clear();
+  // todo: fill supportCodeLibrary.originalCoordinates as it is used in snippets?
+}
+function getFirstNonAutoInjectFixture(fixturesArg, stepConfig) {
+  // there should be exatcly one suitable fixture in fixturesArg
+  const fixtureNames = Object.keys(fixturesArg).filter(fixtureName => !(0, _bddFixtures.isBddAutoInjectFixture)(fixtureName));
+  if (fixtureNames.length === 0) {
+    throw new Error(`No suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  if (fixtureNames.length > 1) {
+    throw new Error(`Several suitable fixtures found for decorator step "${stepConfig.pattern}"`);
+  }
+  return fixturesArg[fixtureNames[0]];
+}
+function saveStepConfigToMethod(method, stepConfig) {
+  method[decoratedStepSymbol] = stepConfig;
+}
+function getStepConfigFromMethod(descriptor) {
+  // filter out getters / setters
+  return typeof descriptor.value === 'function' ? descriptor.value[decoratedStepSymbol] : undefined;
+}

package/build/bdd-framework/stepDefinitions/defineStep.js

@@ -0,0 +1,62 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildCucumberStepCode = buildCucumberStepCode;
+exports.defineStep = defineStep;
+exports.getStepCode = getStepCode;
+var _cucumber = require("@cucumber/cucumber");
+var _exit = require("../utils/exit");
+/**
+ * Defines step by config.
+ * Calls cucumber's Given(), When(), Then() under the hood.
+ */
+function defineStep(stepConfig) {
+  const {
+    keyword,
+    pattern
+  } = stepConfig;
+  const cucumberDefineStepFn = getCucumberDefineStepFn(keyword);
+  const code = buildCucumberStepCode(stepConfig);
+  try {
+    cucumberDefineStepFn(pattern, code);
+  } catch (e) {
+    // todo: detect that this is import from test file
+    // and skip/delay registering cucumber steps until cucumber is loaded
+    const isMissingCucumber = /Cucumber that isn't running/i.test(e.message);
+    if (isMissingCucumber) {
+      (0, _exit.exit)(`Option "importTestFrom" should point to a separate file without step definitions`, `(e.g. without calls of Given, When, Then)`);
+    } else {
+      throw e;
+    }
+  }
+}
+function buildCucumberStepCode(stepConfig) {
+  const code = function (...args) {
+    // build the first argument (fixtures) for step fn
+    const fixturesArg = Object.assign({}, this.stepFixtures, {
+      $testInfo: this.testInfo,
+      $test: this.test,
+      $tags: this.tags
+    });
+    return stepConfig.fn.call(this, fixturesArg, ...args);
+  };
+  code.stepConfig = stepConfig;
+  return code;
+}
+function getStepCode(stepDefinition) {
+  return stepDefinition.code;
+}
+function getCucumberDefineStepFn(keyword) {
+  switch (keyword) {
+    case 'Given':
+      return _cucumber.Given;
+    case 'When':
+      return _cucumber.When;
+    case 'Then':
+      return _cucumber.Then;
+    default:
+      return _cucumber.defineStep;
+  }
+}

package/build/bdd-framework/stepDefinitions/stepConfig.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getStepConfig = getStepConfig;
+exports.isDecorator = isDecorator;
+exports.isPlaywrightStyle = isPlaywrightStyle;
+/**
+ * Playwright-bdd's step config.
+ */
+function getStepConfig(step) {
+  return step.code.stepConfig;
+}
+function isDecorator(stepConfig) {
+  return Boolean(stepConfig === null || stepConfig === void 0 ? void 0 : stepConfig.pomNode);
+}
+/**
+ * Cucumber-style steps don't have stepConfig
+ * b/c they created directly via cucumber's Given, When, Then.
+ */
+function isPlaywrightStyle(stepConfig) {
+  return Boolean(stepConfig);
+}

package/build/bdd-framework/utils/exit.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.exit = exit;
+exports.withExitHandler = withExitHandler;
+var _worker_threads = require("worker_threads");
+/**
+ * Exit utils.
+ *
+ * When calling process.exit() in worker thread used for test-file generation,
+ * logs are not flushed (https://github.com/vitalets/playwright-bdd/issues/59).
+ * That's why instead of process.exit we throw ExitError
+ * that just sets process.exitCode = 1 and allow program to exit normally.
+ * This esnured by wrapping code with withExitHandler().
+ *
+ * On the other hand, when running in the main thread, especially inside Playwright,
+ * thrown error is captured by Playwright and show with additional messages (e.g. no tests found).
+ * That's why in main thread we to call process.exit() to show only needed error.
+ *
+ * Relevant discussions:
+ * - https://github.com/nodejs/node/issues/6379
+ * - https://github.com/nodejs/node-v0.x-archive/issues/3737
+ * - https://github.com/cucumber/cucumber-js/pull/123
+ */
+
+class ExitError extends Error {
+  get stack() {
+    return '';
+  }
+}
+async function withExitHandler(fn) {
+  try {
+    return await fn();
+  } catch (e) {
+    if (e instanceof ExitError) {
+      if (e.message) {
+        // eslint-disable-next-line no-console
+        console.error(e.message);
+      }
+      process.exitCode = 1;
+    } else {
+      throw e;
+    }
+  }
+}
+function exit(...messages) {
+  messages = messages.filter(Boolean);
+  if (_worker_threads.isMainThread) {
+    if (messages.length) {
+      logger.error('Error:', ...messages);
+    }
+    process.exit(1);
+  } else {
+    throw new ExitError(messages.join(' '));
+  }
+}

package/build/bdd-framework/utils/index.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.callWithTimeout = callWithTimeout;
+exports.extractTemplateParams = extractTemplateParams;
+exports.getPackageVersion = getPackageVersion;
+exports.getSymbolByName = getSymbolByName;
+exports.removeDuplicates = removeDuplicates;
+exports.resolvePackageRoot = resolvePackageRoot;
+exports.template = template;
+var _fs = _interopRequireDefault(require("fs"));
+var _path = _interopRequireDefault(require("path"));
+var _util = require("util");
+const setTimeoutPromise = (0, _util.promisify)(setTimeout);
+/**
+ * Returns Symbol by name.
+ * See: https://stackoverflow.com/questions/50453640/how-can-i-get-the-value-of-a-symbol-property
+ */
+function getSymbolByName(target, name) {
+  const ownKeys = Reflect.ownKeys(target);
+  const symbol = ownKeys.find(key => key.toString() === `Symbol(${name})`);
+  if (!symbol) {
+    throw new Error(`Symbol "${name}" not found in target. ownKeys: ${ownKeys}`);
+  }
+  return symbol;
+}
+/**
+ * Inserts params into template.
+ * Params defined as <param>.
+ */
+function template(t, params = {}) {
+  return t.replace(/<(.+?)>/g, (match, key) => {
+    return params[key] !== undefined ? String(params[key]) : match;
+  });
+}
+/**
+ * Extracts all template params from string.
+ * Params defined as <param>.
+ */
+function extractTemplateParams(t) {
+  return [...t.matchAll(/<(.+?)>/g)].map(m => m[1]);
+}
+function removeDuplicates(arr) {
+  return [...new Set(arr)];
+}
+function resolvePackageRoot(packageName) {
+  const packageJsonPath = require.resolve(`${packageName}/package.json`);
+  return _path.default.dirname(packageJsonPath);
+}
+function getPackageVersion(packageName) {
+  const packageRoot = resolvePackageRoot(packageName);
+  const packageJsonPath = _path.default.join(packageRoot, 'package.json');
+  const packageJson = JSON.parse(_fs.default.readFileSync(packageJsonPath, 'utf8'));
+  return packageJson.version || '';
+}
+async function callWithTimeout(fn, timeout, timeoutMsg) {
+  if (!timeout) {
+    return fn();
+  }
+  const ac = new AbortController();
+  return Promise.race([fn(), setTimeoutPromise(timeout, null, {
+    ref: false,
+    signal: ac.signal
+  }).then(() => {
+    throw new Error(timeoutMsg || `Function timeout (${timeout} ms)`);
+  })]).finally(() => ac.abort());
+}

package/build/bdd-framework/utils/jsStringWrap.js

@@ -0,0 +1,44 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.jsStringWrap = jsStringWrap;
+/**
+ * Adopted version of https://github.com/joliss/js-string-escape
+ * - added support of backticks
+ * - added 'quotes' option to indicate which quotes to escape
+ * - wrap result string with provided quotes
+ *
+ * Considered alternative is https://github.com/mathiasbynens/jsesc,
+ * but it provides additional functionality and much slower
+ * See: https://github.com/mathiasbynens/jsesc/issues/16
+ */
+function jsStringWrap(str, {
+  quotes = 'single'
+} = {}) {
+  const wrapQuote = quotes === 'single' ? "'" : quotes === 'double' ? '"' : '`';
+  // eslint-disable-next-line complexity
+  const escapedStr = ('' + str).replace(/["'`\\\n\r\u2028\u2029]/g, character => {
+    // Escape all characters not included in SingleStringCharacters and
+    // DoubleStringCharacters on
+    // http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4
+    switch (character) {
+      case wrapQuote:
+      case '\\':
+        return '\\' + character;
+      // Four possible LineTerminator characters need to be escaped:
+      case '\n':
+        return '\\n';
+      case '\r':
+        return '\\r';
+      case '\u2028':
+        return '\\u2028';
+      case '\u2029':
+        return '\\u2029';
+      default:
+        return character;
+    }
+  });
+  return `${wrapQuote}${escapedStr}${wrapQuote}`;
+}

package/build/bdd-framework/utils/logger.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.logger = exports.Logger = void 0;
+/**
+ * Simple logger
+ */
+class Logger {
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  log(...args) {
+    if (this.options.verbose) {
+      console.log(...args);
+    }
+  }
+  warn(...args) {
+    // using log() to output warnings to stdout, not stderr
+    console.log(...args);
+  }
+  error(...args) {
+    console.error(...args);
+  }
+}
+// default logger
+exports.Logger = Logger;
+const logger = exports.logger = new Logger();

package/build/bdd-poc/core-runner/main.js

@@ -0,0 +1,10 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createCucumberBDD = createCucumberBDD;
+var _stepFileGenerate = require("../test/stepGenerate/stepFileGenerate");
+async function createCucumberBDD() {
+  await (0, _stepFileGenerate.generateSpecFiles)();
+}

package/build/bdd-poc/core-runner/stepDefinitions.js

@@ -27,7 +27,6 @@ function getInputArray(description, argument) {
     return [specInput.dataTableStep];
   }
   if (specInput.scenarioTable) {
-    console.log(specInput.inputParameter);
     var exceedParam = specInput.inputParameter[0];
     const extracted = argument.map(element => {
       return exceedParam[element];

package/build/bdd-poc/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createBdd", {
+  enumerable: true,
+  get: function () {
+    return _exportMethods.createBdd;
+  }
+});
+Object.defineProperty(exports, "createCucumberBDD", {
+  enumerable: true,
+  get: function () {
+    return _main.createCucumberBDD;
+  }
+});
+Object.defineProperty(exports, "createNativeBDD", {
+  enumerable: true,
+  get: function () {
+    return _stepDefinitions.createNativeBDD;
+  }
+});
+var _exportMethods = require("./core-runner/exportMethods");
+var _stepDefinitions = require("./core-runner/stepDefinitions");
+var _main = require("./core-runner/main");

package/build/bdd-poc/test/stepGenerate/stepFileGenerate.js

@@ -11,18 +11,18 @@ var _path = _interopRequireDefault(require("path"));
 var _featureFileParer = require("../cucumber/featureFileParer");
 var _testStructure = require("../testStructure");
 async function stepFileCreation(featureContent, stepFilename, featureFilePath) {
-  const generatedFolderPath = _path.default.resolve(process.cwd(), 'uat', 'feature-gen');
-  if (!(0, _fs.existsSync)(generatedFolderPath)) {
-    (0, _fs.mkdirSync)(generatedFolderPath, {
-      recursive: true
-    });
-  }
   const stepsFilePath = _path.default.resolve(process.cwd(), 'uat', 'feature-gen', stepFilename);
   const stepsSnippets = (0, _testStructure.testSnippet)(featureContent, featureFilePath);
   await (0, _fs.writeFileSync)(stepsFilePath, stepsSnippets);
 }
 function generateSpecFiles() {
   const featureFilePattern = _path.default.resolve(process.cwd(), 'uat', 'modules', '**', '**', '**', '**', '**', '**', '**', '**', '*.feature').split(`\\`).join('/');
+  const generatedFolderPath = _path.default.resolve(process.cwd(), 'uat', 'feature-gen');
+  if (!(0, _fs.existsSync)(generatedFolderPath)) {
+    (0, _fs.mkdirSync)(generatedFolderPath, {
+      recursive: true
+    });
+  }
   _fastGlob.default.globSync(featureFilePattern, {
     dot: true,
     cwd: process.cwd()

package/build/bdd-poc/test/stepGenerate/stepsnippets.js

@@ -8,8 +8,7 @@ exports.testCase = testCase;
 exports.testFile = testFile;
 exports.testStep = testStep;
 exports.testSuite = testSuite;
-const TESTING_LIBRARY = '@zohodesk/testinglibrary';
-exports.TESTING_LIBRARY = TESTING_LIBRARY;
+const TESTING_LIBRARY = exports.TESTING_LIBRARY = '@zohodesk/testinglibrary';
 function testStep(keyword, description, browserObject, testData, options) {
   return `await $${keyword}('${description}')(${browserObject},${testData})\n`;
 }

package/build/bdd-poc/test/testDataMap.js

@@ -5,7 +5,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.testDataCreation = testDataCreation;
-var _gherkin = _interopRequireDefault(require("@cucumber/gherkin"));
+var _gherkin = require("@cucumber/gherkin");
 var _messages = require("@cucumber/messages");
 var _fastGlob = _interopRequireDefault(require("fast-glob"));
 var _fs = require("fs");
@@ -13,12 +13,12 @@ var _path = _interopRequireDefault(require("path"));
 var _testStructure = require("./testStructure");
 async function testDataCreation() {
   var uuidFn = _messages.IdGenerator.uuid();
-  var builder = new _gherkin.default.AstBuilder(uuidFn);
-  var matcher = new _gherkin.default.GherkinClassicTokenMatcher();
-  var parser = new _gherkin.default.Parser(builder, matcher);
+  var builder = new _gherkin.AstBuilder(uuidFn);
+  var matcher = new _gherkin.GherkinClassicTokenMatcher();
+  var parser = new _gherkin.Parser(builder, matcher);
   var exampleSteps = [];
   const globalTestdata = new Map();
-  const actualStepFilePath = _path.default.resolve('uat', 'modules', '**', '**', '**', '**', '**', '*.spec.js').split('\\').join('/');
+  const actualStepFilePath = _path.default.resolve('uat', 'modules', '**', '**', '**', '**', '**', '*.feature').split('\\').join('/');
   await _fastGlob.default.globSync(actualStepFilePath, {
     dot: true,
     cwd: process.cwd()

package/build/core/jest/preprocessor/jsPreprocessor.js

@@ -6,8 +6,7 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 var _babelJest = _interopRequireDefault(require("babel-jest"));
-var _default = _babelJest.default.createTransformer({
+var _default = exports.default = _babelJest.default.createTransformer({
   presets: [require.resolve('@babel/preset-env'), require.resolve('@babel/preset-react')],
   plugins: [require.resolve('babel-plugin-transform-dynamic-import')]
-});
-exports.default = _default;
+});

package/build/core/playwright/builtInFixtures/addTags.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  addTags: [async ({
+    $tags
+  }, use, testInfo) => {
+    testInfo.annotations.push({
+      type: 'tags',
+      description: $tags.join(', ')
+    });
+    await use();
+  }, {
+    auto: true
+  }]
+};

package/build/core/playwright/builtInFixtures/cacheLayer.js

@@ -0,0 +1,13 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const cacheMap = new Map();
+var _default = exports.default = {
+  // eslint-disable-next-line no-empty-pattern
+  cacheLayer: async ({}, use) => {
+    await use(cacheMap);
+  }
+};

package/build/core/playwright/builtInFixtures/context.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _default = exports.default = {
+  context: async ({
+    context
+  }, use) => {
+    // eslint-disable-next-line no-undef
+    await context.addInitScript(() => window.localStorage.setItem('isDnBannerHide', true));
+    await use(context);
+  }
+};

package/build/core/playwright/builtInFixtures/index.js

@@ -0,0 +1,26 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _page = _interopRequireDefault(require("./page"));
+var _context = _interopRequireDefault(require("./context"));
+var _cacheLayer = _interopRequireDefault(require("./cacheLayer"));
+var _addTags = _interopRequireDefault(require("./addTags"));
+function getBuiltInFixtures(bddMode) {
+  let builtInFixtures = {
+    ..._page.default,
+    ..._context.default,
+    ..._cacheLayer.default
+  };
+  if (bddMode) {
+    builtInFixtures = {
+      ...builtInFixtures,
+      ..._addTags.default
+    };
+  }
+  return builtInFixtures;
+}
+var _default = exports.default = getBuiltInFixtures;

package/build/core/playwright/builtInFixtures/page.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+// function test(descrition, callback) {
+//   return test(descrition, ({ page }) => {
+//     const { locator, ...custompage } = page
+//     callback({ page: custompage })
+//   })
+// }
+// class FilteredPage {
+//   constructor(page) {
+//     this.page = page;
+//     this.allowedMethods = ['getByText', 'getByTitle'];
+//     this.context = page.context;
+//   }
+//   goto(...args) {
+//     return this.page['goto'](...args);
+//   }
+//   getByRole(...args) {
+//     return this.page['getByRole'](...args);
+//   }
+// }
+// function FilteredPage(page) {
+//   return {
+//     getByRole: () => {
+//       throw new Error('You cannnot use getByRole property')
+//     }
+//   }
+// }
+var _default = exports.default = {
+  page: async ({
+    page
+  }, use) => {
+    page.getBaseUrl = function () {
+      if (process.env.mode === 'dev') {
+        return `${process.env.domain}?devURL=${process.env.devUrl}`;
+      }
+      return `${process.env.domain}`;
+    };
+    page.getCustomPageUrl = function (url) {
+      if (process.env.mode === 'dev') {
+        return `${process.env.domain}/${url}?devURL=${process.env.devUrl}`;
+      }
+      return `${process.env.domain}/${url}`;
+    };
+    await use(page);
+  }
+};

package/build/core/playwright/clear-caches.js

@@ -0,0 +1,29 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _fileUtils = require("../../utils/fileUtils");
+var _logger = require("../../utils/logger");
+var _readConfigFile = require("./readConfigFile");
+function clearCaches() {
+  try {
+    const {
+      authFilePath,
+      reportPath
+    } = (0, _readConfigFile.generateConfigFromFile)();
+    authFilePath.split('/').pop();
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting auth files present in ${authFilePath}`);
+    (0, _fileUtils.deleteFolder)(_path.default.resolve(process.cwd(), authFilePath));
+    _logger.Logger.log(_logger.Logger.INFO_TYPE, `Deleting Playwright report ${reportPath}`);
+    (0, _fileUtils.deleteFolder)(reportPath);
+    (0, _fileUtils.deleteFolder)(_path.default.resolve(process.cwd(), 'uat', '.features-gen'));
+    _logger.Logger.log(_logger.Logger.SUCCESS_TYPE, 'Caches Cleared');
+  } catch (err) {
+    _logger.Logger.log(_logger.Logger.FAILURE_TYPE, 'Error While clearing cookies');
+  }
+}
+var _default = exports.default = clearCaches;