Task command for Node operations in Cypress - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Cypress task command?

Consider this Cypress task command that reads a file using Node.js fs module. What will be logged in the test runner console?

Cypress

Cypress.Commands.add('readFileTask', (filePath) => {
  return cy.task('readFile', filePath);
});

// In plugins/index.js
module.exports = (on) => {
  const fs = require('fs');
  on('task', {
    readFile(filePath) {
      return fs.readFileSync(filePath, 'utf8');
    }
  });
};

// Test code
cy.readFileTask('cypress/fixtures/sample.txt').then((content) => {
  cy.log(content);
});

A Logs the content of 'sample.txt' as a string in the Cypress test runner

B Throws a syntax error because fs.readFileSync is used incorrectly

C Fails with an error because 'task' is not defined in Cypress commands

D Logs an object with file metadata instead of content

💡 Hint

Remember that Cypress tasks run Node code outside the browser context and can return values to the test.

The task 'readFile' uses Node's fs.readFileSync to read the file content synchronously and returns it as a string. The Cypress command calls this task and logs the string content.

❓ assertion

intermediate

Which assertion correctly verifies the result of a Cypress task?

You have a Cypress task that returns the number of files in a directory. Which assertion correctly checks that the count is 5?

Cypress

cy.task('countFiles', 'cypress/fixtures').then((count) => {
  // Which assertion goes here?
});

A assert.isTrue(count === 5);

B assert.isFalse(count !== 5);

C expect(count).to.equal(5);

D expect(count).to.be.greaterThan(5);

💡 Hint

Use the most direct and readable assertion for equality.

The assertion expect(count).to.equal(5) directly checks that count equals 5, which is clear and idiomatic in Cypress tests.

🔧 Debug

advanced

Why does this Cypress task fail with 'Cannot read property' error?

Given this task code, why does the test fail with "ENOENT: no such file or directory" error?

Cypress

// plugins/index.js
module.exports = (on) => {
  on('task', {
    countFiles(dir) {
      const fs = require('fs');
      const files = fs.readdirSync(dir);
      return files.length;
    }
  });
};

// Test code
cy.task('countFiles', 'cypress/fixtures').then((count) => {
  expect(count).to.be.a('number');
});

A The directory path passed is incorrect or does not exist, so fs.readdirSync throws an error

B The 'on' function is not properly imported in plugins file

C The task function is missing a return statement

D The test code does not handle the promise returned by cy.task

💡 Hint

Check if the directory path is valid and accessible by Node.

If the directory path is wrong, fs.readdirSync throws an error (e.g., ENOENT), causing the task to fail.

🧠 Conceptual

advanced

What is the main benefit of using Cypress task commands for Node operations?

Why should you use Cypress task commands to perform Node.js operations instead of running them directly in test code?

A Because task commands automatically retry on failure

B Because task commands run faster than browser code

C Because Cypress does not support asynchronous code in tests

D Because Cypress test code runs in the browser and cannot access Node APIs directly

💡 Hint

Think about the environment where Cypress test code runs versus where Node code runs.

Cypress test code runs inside the browser environment, which does not have access to Node.js APIs like file system or OS modules. Tasks run in the Node environment, enabling such operations.

❓ framework

expert

Which is the correct way to define and use a Cypress task that deletes a file?

You want to create a Cypress task named 'deleteFile' that deletes a file at a given path. Which option correctly defines the task and uses it in a test?

A

// plugins/index.js
module.exports = (on) => {
  const fs = require('fs');
  on('task', {
    deleteFile(filePath) {
      return fs.unlink(filePath);
    }
  });
};

// Test code
cy.task('deleteFile', 'cypress/fixtures/temp.txt').then(() => {
  cy.log('File deleted');
});

B

// plugins/index.js
module.exports = (on) => {
  const fs = require('fs');
  on('task', {
    deleteFile(filePath) {
      fs.unlinkSync(filePath);
      return null;
    }
  });
};

// Test code
cy.task('deleteFile', 'cypress/fixtures/temp.txt').then((result) => {
  expect(result).to.be.null;
});

C

// plugins/index.js
module.exports = (on) => {
  const fs = require('fs');
  on('task', {
    deleteFile(filePath) {
      fs.unlinkSync(filePath);
    }
  });
};

// Test code
cy.task('deleteFile', 'cypress/fixtures/temp.txt').then((res) => {
  expect(res).to.equal('deleted');
});

D

// plugins/index.js
module.exports = (on) => {
  const fs = require('fs');
  on('task', {
    deleteFile(filePath) {
      fs.unlink(filePath, (err) => {
        if (err) throw err;
      });
      return 'done';
    }
  });
};

// Test code
cy.task('deleteFile', 'cypress/fixtures/temp.txt').then((res) => {
  expect(res).to.equal('done');
});

💡 Hint

Remember that tasks must return a value or null, and asynchronous callbacks must be handled properly.

Option B uses fs.unlinkSync to synchronously delete the file and returns null to indicate success. This matches Cypress task expectations. Option B returns fs.unlink which is async and returns undefined, causing Cypress to hang. Option B does not return anything, so the test assertion fails. Option B returns 'done' immediately but the async unlink callback may not have completed, causing unreliable behavior.