How can I use the same value as written in the Json during the same test execution in the testcafe

Question

I have been trying to use the value from the JSON that I have got added successfully using fs.write() function,

There are two test cases in the same fixture, one to create an ID and 2nd to use that id. I can wrote the id successfully in the json file using fs.write() function and trying to use that id using importing json file like var myid=require('../../resources/id.json')

The json file storing correct id of the current execution but I get the id of first test execution in 2nd execution.

For example, id:1234 is stored during first test execution and id:4567 is stored in 2nd test execution. During 2nd test execution I need the id:4567 but I get 1234 this is weird, isn't it?

I use it like t.typeText(ele, myid.orid)

my json file contains only id like {"orid":"4567"}

I am new to Javascript and Testcafe any help would really be appreciated

Write File class

const fs = require('fs')
const baseClass =require('../component/base')
class WriteIntoFile{
    constructor(orderID){
        const OID = {
            orderid: orderID
        }
        const jsonString = JSON.stringify(OID)
        fs.writeFile(`resources\id.json`, jsonString, err => {
            if (err) {
                console.log('Error writing file', err)
            } else {
                console.log('Successfully wrote file')
            }
        })
    }
}
export default WriteIntoFile

I created 2 different classes in order to separate create & update operations and call the functions of create & update order in single fixture in test file

Create Order class

class CreateOrder{

        ----
        ----
        ----
    async createNewOrder(){
    //get text of created ordder and saved order id in to the json file
        -----
        -----
        -----
   const orId= await baseclass.getOrderId();
   new WriteIntoFile(orId)
   console.log(orId)
   
        -----
        -----
        -----
}
}export default CreateOrder

Update Order class

var id=require('../../resources/id.json')
class UpdateOrder{
async searchOrderToUpdate(){
     await t
    ***//Here, I get old order id that was saved during previous execution***
    .typeText(baseClass.searchBox, id.orderid)
    .wait(2500)
    .click(baseClass.searchIcon)
    .doubleClick(baseClass.orderAGgrid)
    console.log(id.ordderid)
    
    ----
    ----
    async updateOrder(){
        this.searchOrderToUpdate()
        .typeText(baseClass.phNo, '1234567890')
        .click(baseClass.saveBtn) 
    }
    
}export default UpdateOrder

Test file

const newOrder = new CreateOrder();
const update = new UpdateOrder();
const role = Role(`siteurl`, async t => {
    await t 
   login('id')
    await t
   .wait(1500)
  },{preserveUrl:true})

  test('Should be able to create an Order', async t=>{
    await newOrder.createNewOrder();
  });
  test('Should be able to update an order', async t=>{
       
    await update.updateOrder();
  });

Answer 1

I'll reply to this, but you probably won't be happy with my answer, because I wouldn't go down this same path as you proposed in your code.

I can see a couple of problems. Some of them might not be problems right now, but in a month, you could struggle with this.

1/ You are creating separate test cases that are dependent on each other.

This is a problem because of these reasons:

• what if Should be able to create an Order doesn't run? or what if it fails? then Should be able to update an order fails as well, and this information is useless, because it wasn't the update operation that failed, but the fact that you didn't meet all preconditions for the test case
• how do you make sure Should be able to create an Order always runs before hould be able to update an order? There's no way! You can do it like this when one comes before the other and I think it will work, but in some time you decide to move one test somewhere else and you are in trouble and you'll spend hours debugging it. You have prepared a trap for yourself. I wrote this answer on this very topic, you can read it.
• you can't run the tests in parallel
• when I read your test file, there's no visible hint that the tests are dependent on each other. Therefore as a stranger to your code, I could easily mess things up because I have no way of knowing about it without going deeper in the code. This is a big trap for anyone who might come to your code after you. Don't do this to your colleagues.

2/ Working with files when all you need to do is pass a value around is too cumbersome.

I really don't see a reason why you need to same the id into a file. A slightly better approach (still violating 1/) could be:

const newOrder = new CreateOrder();
const update = new UpdateOrder();

// use a variable to pass the orderId around
// it's also visible that the tests are dependent on each other
let orderId = undefined;

const role = Role(`siteurl`, async t => {
    // some steps, I omit this for better readability
}, {preserveUrl: true})

test('Should be able to create an Order', async t=>{
    orderId = await newOrder.createNewOrder();
});

test('Should be able to update an order', async t=>{
   await update.updateOrder(orderId);
});

Doing it like this also slightly remedies what I wrote in 1/, that is that it's not visible at first sight that the tests are dependent on each other. Now, this is a bit improved.

Some other approaches how you can pass data around are mentioned here and here.

Perhaps even a better approach is to use t.fixtureCtx object:

const newOrder = new CreateOrder();
const update = new UpdateOrder();

const role = Role(`siteurl`, async t => {
    // some steps, I omit this for better readability
}, {preserveUrl:true})

test('Should be able to create an Order', async t=>{
    t.fixtureCtx.orderId = await newOrder.createNewOrder();
});

test('Should be able to update an order', async t=>{
   await update.updateOrder(t.fixtureCtx.orderId);
});

Again, I can at least see the tests are dependent on each other. That's already a big victory.

---

Now back to your question:

During 2nd test execution I need the id:4567 but I get 1234 this is weird, isn't it?

No, it's not weird. You required the file:

var id = require('../../resources/id.json')

and so it's loaded once and if you write into the file later, you won't read the new content unless you read the file again. require() is a function in Node to load modules, and it makes sense to load them once.

This demonstrates the problem:

const idFile = require('./id.json');
const fs = require('fs');

console.log(idFile); // { id: 5 }
const newId = {
    'id': 7
};
fs.writeFileSync('id.json', JSON.stringify(newId));
// it's been loaded once, you won't get any other value here
console.log(idFile); // { id: 5 }

What you can do to solve the problem?

You can use fs.readFileSync():

const idFile = require('./id.json');
const fs = require('fs');

console.log(idFile); // { id: 5 }
const newId = {
    'id': 7
};
fs.writeFileSync('id.json', JSON.stringify(newId));
// you need to read the file again and parse its content
const newContent = JSON.parse(fs.readFileSync('id.json'));
console.log(newContent); // { id: 7 }

And this is what I warned you against in the comment section. That this is too cumbersome, inefficient, because you write to a file and then read from the file just to get one value.

What you created is not very readable either:

const fs = require('fs')
const baseClass =require('../component/base')
class WriteIntoFile{
    constructor(orderID){
        const OID = {
            orderid: orderID
        }
        const jsonString = JSON.stringify(OID)
        fs.writeFile(`resources\id.json`, jsonString, err => {
            if (err) {
                console.log('Error writing file', err)
            } else {
                console.log('Successfully wrote file')
            }
        })
    }
}
export default WriteIntoFile

All these operations for writing into a file are in a constructor, but a constructor is not the best place for all this. Ideally you have only variable assignments in it. I also don't see much reason for why you need to create a new class when you are doing only two operations that can easily fit on one line of code:

fs.writeFileSync('orderId.json', JSON.stringify({ orderid: orderId }));

Keep it as simple as possible. it's more readable like so than having to go to a separate file with the class and decypher what it does there.