Where are these variables ("aliases") coming from?

[marco-globality]

Hi there!

So my team is using aliases to set some important variables which are used within the it('Test',) blocks.

So for example, we may be running the following command in a before step:

cy.setupSomeDynamicData()

Then the setupSomeDynamicData() method exists in a another file (ex: commands.js) and the setupSomeDynamicData() method may setup a couple aliases:

cypress/support/commands.js

 setupSomeDynamicData() {
      cy.createDynamicString(first).as('String1')
      cy.createDynamicString(second).as('String2')
      cy.createDynamicString(third).as('String3')
    },

So now we go back to our spec/test file, and start using these aliases:

cypress/e2e/smallTest.cy.js

        it('A small example test', function () {
             cy.visit(this.String1)
             // do some stuff...
             cy.get(this.String2)
             // do some stuff...
             cy.visit(this.String3)
            // do some stuff...
        })

The problem is that unless you're the person who wrote the code, it's not obvious where this.String1, this.String2, or this.String3 are coming from nor when they were initialized (from the perspective of smallTest.cy.js) since the code that initializes the aliases is being executed in another file.

In this example, it's quite easy to Ctrl+F the codebase and search for these aliases but you have to really start doing some reverse engineering once you have more complex use cases.

I guess this feels like some sort of readability/maintainability problem because once you setup enough of these and the example I provided starts to get more complex then finding out where these aliases are created can be inconvenient. The this.* syntax makes it feel like you'd find these aliases variables somewhere within the same file in which they're being used but when you don't see any sign of them then it becomes evident that they've just magically been initialized (somewhere/somehow) and then the hunt 🕵🏼‍♂️ begins.

Some solutions that come to mind (which may be bad ideas) are:

• Create JS objects with getters/setters. This way, it'll be a bit easier to trace where the variable you're using was "set"
• Not use aliases, and instead, use global variables that can be imported into the spec/test files so it's clear where they are coming from then run a before/after hook to clear these variables so that the reset-per-test functionality remains.
• Name the variables in a way where it's obvious that they are aliased and then spread the word/document this method within my team so that anytime they see "this.aliasedString2" then they know it's coming from some method that performs these alias assignments.

Anyhow, I'm sure there may be a better way to handle this so just thought I'd post this question.

Thanks :)