{"componentChunkName":"component---src-templates-tag-js","path":"/tags/qa/","result":{"data":{"site":{"siteMetadata":{"title":"LoginRadius Blog"}},"allMarkdownRemark":{"totalCount":4,"edges":[{"node":{"fields":{"slug":"/engineering/challenges-faced-by-qa/"},"html":"

In the whole software development process, QA testing has a unique space. QA is responsible for ensuring that developed software is bug-free and works concerning technical and business requirements.

\n

QA engineers must have a good understanding of each project and what it means to accomplish. They must deliver quality software to the clients.

\n

Given the responsibility of a QA's job, it is natural to face many challenges in their day-to-day tasks. This article will help to understand the most common of those challenges faced by any QA.

\n

1. Unstable Environment

\n

Usually, QA teams face unstable environment setup issues that we need to prepare for most of what we have. Sometimes the server gets stuck due to overload and requires a restart many times during testing etc.

\n

Escalate these issues to the seniors and make sure you get the environment ready for the testing.

\n

2. Tools Being Force-fed

\n

Now and then, we realize that a tool is not the right choice for the project. We do not have any other option but to keep using it because the clients/organization already have licenses and would not go for a new one until the current license expires.

\n

It is not fun, but you learn alternate options. Or at least, one can conclude with regards to if the possibilities work.

\n

3. Tight Deadlines

\n

The biggest challenge QA is to receive requests for last-minute testing. The primary reasons for such demands are that the development process takes more time than expected and the time for testing is underestimated. Generally, testing and debugging take 50% of the development time. When QA has a short time frame for verification, they should check software against the main business specifications. Software testing should begin at least three days of release.

\n

4. Testing Documents Created By Others

\n

In the case of QA, it's faster to create a document from scratch than to use the one created by others. Using test cases created by others increases the time of verification and puts limits as far as discovering bugs.

\n

5. Friday Releases

\n

Everybody thinks of the successful releases of new features or products, but the reality could be different. From our testing experience, the software doesn't typically release from the first time in most cases. The best time for releasing the software is the start of the week. Thus it gives development and QA teams the rest of the week to manage with whatever comes up.

\n

6. Wrong Testing Estimation

\n

While trying to make an accurate estimate, some software estimations could be entirely unpredictable and go wrong. As developers, QA also doesn't have 100% security from unexpected issues.

\n

7. Fixing Bugs During Testing

\n

Developers and QA engineers should work closely. Testing should be done once part of the development process is done, and after that, bug fixing activity should start. QA submit a test report and only after that debugging begins.

\n

8. Last-Minute Changes to Requirements

\n

It is slightly common to change project requirements mid-sprint in agile development projects. While this can be frustrating for the team and due to that testers can be affected. They may need to re-try the whole extent of testing since even the littlest changes to a codebase should be gone through various tests to guarantee its steadiness and similarity with existing code.

\n

Naturally, last-minute changes in the requirement can be difficult for testers to deal with, especially if there are tight deadlines to deliver results.

\n

9. Insufficient Coordinated Effort Among Developers and Testers

\n

Professional differences between development and testing teams are still common. Developers think that testing is a final process of the software development life cycle, and testers do not require anything apart from a list of user journeys and technical requirements.

\n

However, testers may have difficulty identifying flaws in the code if they are not acquainted with the development process. If they do not understand how the software works, they will have trouble creating test cases to find all possible bugs.

\n

Conclusion

\n

Resolving the challenges mentioned above will not only make the lives of QA testers much easier. Still, it will also streamline the software development process to make it more useful and time-efficient. By making it easy for QAs to do their job well, organizations can ensure that their products meet all business requirements and function in the best possible way.

\n","frontmatter":{"date":"March 05, 2021","updated_date":null,"title":"Top 9 Challenges Faced by Every QA","tags":["QA","Processes","Testing"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.9047619047619047,"src":"/static/3cb5bace33cd7de67d48a1447d9512a7/58556/testing-challenges.webp","srcSet":"/static/3cb5bace33cd7de67d48a1447d9512a7/61e93/testing-challenges.webp 200w,\n/static/3cb5bace33cd7de67d48a1447d9512a7/1f5c5/testing-challenges.webp 400w,\n/static/3cb5bace33cd7de67d48a1447d9512a7/58556/testing-challenges.webp 800w,\n/static/3cb5bace33cd7de67d48a1447d9512a7/99238/testing-challenges.webp 1200w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Neha Vyas","github":"nehavyasqa","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/qa-teams-deliver-quality-software/"},"html":"

Being a Quality Analyst, it's our responsibility to run test cycles on the system and push releases every two weeks to ensure the system is updated with the latest fixes and everything is bug free on the live platform. Usually, every release includes amendments as well as fixes done. If we talk about the resources, the team typically has 8-10 resources, including developers and the QA team.

\n

Therefore, we should always be proactive about every release and avoid any stress during the release. Everything has to be managed properly when it comes to execution from the development end or testing from the QA end. For that purpose, we have to follow proper strategies to ensure that everything is getting tested and the release we approve met the expected quality standards.

\n

Break away from the conventional roles and obligations of QA

\n

We have penetrated limits in two ways. In this day and age, we are a client confronting unit, as we get with our clients straightforwardly about their issues which they experience over the software or what are the highlights which they need to join on the stage. Also, we are actively participating in the design discussions or any inputs required from our end, which we receive from the client's end, to make sure we are going in the right direction as per the client's vision. Our testing experience always helps detect any flaw or defects before doing any coding work, which reduces additional efforts and minimizes the work. This way, we can ensure everything is done based on the client's given timeline and a quality outcome.

\n

Opt for releases very carefully

\n

As it's impractical to test everything each time at whatever point you push any delivery. For that reason, you need to focus on the piece of code that has been chipped away. This way, you can test the primary work component without postponing things and afterward run a total test cycle to ensure no other part has been clashed by the changes. For this reason, there is a new delivery check with the group of what piece of code has been refreshed and what are the results, and generally center around that part to run tests. This way, you can focus on the work and endeavors which should be put.

\n

We center around those pieces of the code and utilize existing computerization tests to deal with different parts. If you realize something worked in the final delivery and you're not contacting it in this delivery, at that point, you don't have to invest an excessive amount of time in testing. So base your delivery standards on the new code that is being added.

\n

Always have a proper plan based on priorities

\n

QA has to make sure that whatever work needs to be done is appropriately prioritized. For example, if particular area of a platform is not affecting things much and can be taken care at later stage then it should be on the lowest priority; If less than one percent of our users are on a particular browser, issues specific to that browser stand out enough to be noticed. And the area which is affecting the whole system should be done on the very first priority. There should be priorities defined like – Blocker, Emergency, Highest, High, Normal, and Low! So always work as per the critical attention on a specific feature and consider the target user demands. What is their feedback or issues to which they want to have access? If something moved beyond clients and we find bugs, we need to fix them in the following release.

\n

Always make sure to have proper environments ready!

\n

You will often hear from the development team that, \"…. It works fine with me; there must be some network issue or system issue on your end\". We have to make sure not to have such conflicts in between because, in the end, our goal has to be – Delivering bug free solution!

\n

For that purpose, Our QA and development teams run their tests in the same environment. As our builds move through the development pipeline, we should test the code under the production environment to build our staging environment to simulate our customer's production environments.

\n

Set up a dedicated performance testing team

\n

Always plan to arrange a dedicated performance team who can run tests as soon as a product is steady and tell the team about new versions and requirements to evaluate the performance risks.

\n

To update performance teams with all the latest information and provide them with an environment close to production as you can. To make sure that there shouldn't be any gaps between and can appropriately test the product.

\n

Run a regression cycle

\n

QA team runs regression tests in the last phase of the product cycle, and it is that process that confirms the product delivery. If any of the regression tests fail, QA informs the managers/stakeholders so that appropriate actions can be taken for further release as it's never acceptable to deliver the product if any of the tests fail, which might end up in more significant problems for the team as well as the client. So the QA team always makes sure to run regression tests to verify everything properly.\nWe additionally automate our regression cycle, so it just requires a couple of days to run.

\n

Production environment testing on customer accounts is necessary

\n

As we maintain customer data in our database collections, we need to guarantee that it should remain attuned with any new versions that have been released or about to release. Whenever we release a new version, we run several updates to check that no data was harmed, and in case we find any data-corrupting bugs, those become our highest priority. We also perform manual backward compatibility testing while taking steps towards finding an automated and more efficient approach. Nonetheless, it would be best to do some manual testing, as this is one of the last stages before production.

\n

Sanity testing on production environment

\n

We perform post-release sanity tests on our production account to authorize that everything works as projected, including all third-party systems. We initially perform tests utilizing our existing production account but then create a new account to check that the process will continue to work correctly as new customers register.

\n

Conclusion

\n

The best testing practices should inculcate all other processes in general and risk management processes in particular in them. The focus should be to improve the software's overall quality while aiming to reduce the cost with continuous monitoring during and after the software release. While doing quality assurance testing, the tester should comply with all the fundamental principles and industry practices and look at the product from the end user's perspective.

\n","frontmatter":{"date":"March 01, 2021","updated_date":null,"title":"QA Testing Process: How to Deliver Quality Software","tags":["QA","Processes","Testing"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/129a0973488f0d77139cfcb0f1cb61eb/ad85c/software-testing.webp","srcSet":"/static/129a0973488f0d77139cfcb0f1cb61eb/61e93/software-testing.webp 200w,\n/static/129a0973488f0d77139cfcb0f1cb61eb/1f5c5/software-testing.webp 400w,\n/static/129a0973488f0d77139cfcb0f1cb61eb/ad85c/software-testing.webp 600w","sizes":"(max-width: 600px) 100vw, 600px"}}},"author":{"id":"Neha Vyas","github":"nehavyasqa","avatar":null}}}},{"node":{"fields":{"slug":"/engineering/unit-testing/"},"html":"

A lot has been written and talked about Unit Testing in the IT industry for the last couple of years. I have heard and discussed the same over the previous 2.5 decades of my IT career.

\n

Even though a lot is talked about and is done in this field but still today, every company is struggling with this. But before we proceed with the above situation, let us first understand its importance.

\n

A strong foundation is the basis of a strong building in the same way a proper unit testing is the foundation of high-quality software.

\n

Unit Testing, if done correctly, ensures that each of the building blocks of the software product is robust and will make high-quality software when put together.

\n

Unit testing is an essential tool in any serious software developer's toolbox. However, writing a good unit test for a specific piece of code can often be very hard.

\n

Developers frequently believe that their struggles are triggered by a lack of essential testing expertise or hidden unit testing techniques after experiencing trouble testing their own or someone else's code.

\n

What is Unit Testing?

\n

Testing of the unit requires testing individual components of the programme or application software. The primary objective behind this is to verify that all the individual components function as expected.

\n

As the smallest possible part of the software that can be evaluated, a unit is known. It usually has a couple of inputs and a single output.

\n

Both testers and developers can isolate each module, detect and repair device defects at a very early stage of the life cycle of software development with this testing method (SDLC).

\n

Why Unit Testing is essential?

\n

By considering stubs, mock artifacts, drivers, and unit testing frameworks, this methodology effectively helps validate the consistency of a section of code.

\n

Because it is practiced at the initial testing level, this testing methodology ensures that the vulnerabilities are detected and corrected at the early stage of SDLC, even before they become costly for businesses to repair when they are later identified.

\n

The developers and testers can help save time with a suitable unit testing practice as bugs can be found early in the process as it is the initial testing step. Skipping or restricting the unit testing practice will adversely increase the defects, and repairing them later becomes difficult.

\n

Therefore before preparing for the integration testing, it is essential to practice unit testing at the initial stage of the software testing process.

\n

Why is it difficult to run a smooth unit testing procedure?

\n

Well, it is not that a developer loves to find bugs in his/her coded code. Still, when it comes to unit testing, they at times(most of the time) see it has an additional overhead on them, especially when one has to follow and stick to a lot of protocols, frameworks, and documentation, etc.

\n

Also, it is commonly misunderstood that finding issues is the QC team's problem. We have to code. In my view, it is incorrect thinking as Quality Software is standard or combines commitment from a company and it's the team.

\n

What are the benefits of Unit Testing?

\n

Here are a few benefits of unit testing:

\n

1. Agile process

\n

The most significant advantage of unit testing is this. You would need to make improvements to the old design and code when you add more functionality to any programme, which can be costly and risky. If you use the technique of unit testing, this will save a lot of time and can make the whole process much quicker and simpler.

\n

2. Enhance the Code Quality

\n

Unit testing increases code consistency dramatically. It allows designers to recognize the smallest faults present in the units before they go for integration testing.

\n

3. Fix Software Bugs

\n

At a very early point, unit testing helps detect all sorts of problems with the programme. Until going any further, software developers should then focus on those problems first.

\n

This is the primary benefit of this because no other program component is compromised as the issues are fixed at an early stage. This results in improved performance, decreased downtime, and lower costs that would otherwise occur due to the entire design process's stalling.

\n

4. Facilitates Change

\n

When you test each part of the program individually, refactoring the code or upgrading the device library becomes much simpler. If there are any issues, they are found early on, and it thus becomes much easier to make improvements to the system.

\n

Before it goes on to the next level, the accuracy of each unit is checked. This implies that until it's incorporated with other companies, the device is proven to be in good working order.

\n

5. Provides Documentation

\n

Unit verification considers the whole system's documentation. By reading each module's documentation, developers who want to learn about the features of a specific programme or framework will quickly learn about the device.

\n

It makes it possible for them to have a detailed understanding of the system and what each part does.

\n

6. Seamless Debugging

\n

To a great degree, unit testing will simplify the debugging process. If a particular test fails, it is essential to debug only the most recent improvements made to the code.

\n

7. Reduce Costs

\n

In the early stages, any problems or glitches in the system are detected by unit testing, and the cost of bug fixes is significantly reduced because of this. If these vulnerabilities are found later, so repairing them would be even more costly.

\n

How to do Unit Testing?

\n

It is important for the unit testers to get a step-by-step instructional document in order to practice unit testing with the manual testing process.

\n

However, automated unit testing is often chosen by most companies, taking into account the efforts necessary for manual testing.

\n
    \n
  1. Is my written code fulfilling the business requirement for which I have written the code?
    2. \n
  2. How many other application areas is my code impacting? Are the values passed from the new block causing an impact on existing areas? Here I would like to state that one has to focus more on the behavior of the existing code with new values. The earlier we do it in the coding cycle the better it is in terms of rework at the developer's end.
    3. \n
  3. If you can follow a specific framework like Junit or Nunit etc, for conducting the unit testing is fine, but if not, you are not able to do that it does not matter as I can always pass a set of values(both positive or negative) to my written code.
    4. \n
  4. If there is no Test case management tool for trapping the unit test values, do not worry; just make a .txt file, put the values, and outcomes in that and you can see the same on a shared drive.
    5. \n
  5. Can I write a few automated scripts to execute the repetitive code to save time?
    6. \n
  6. Can I show my code to my next neighboring coder to have a quick look into the same?
    7. \n
  7. If my code involves a UI can I have a quick run-through by a BA or PM or Tester from a usability point of view?
    8. \n
\n

In the end, remember that I am the first and the most basic foundation in a big building of Quality and have to always keep the same in mind whenever I code since no one is interested in buying a well-packaged product if its ingredients are not of high quality.

\n

By doing the above I am not only contributing to high-quality software but I can devote later high bug-fixing time to things like improving the performance/security of my code and avoiding going back to the drawing board for issues related to performance or security etc.

\n

Always remember in the software development unit testing serves as \"A stitch in time saves nine\".

\n","frontmatter":{"date":"September 29, 2020","updated_date":null,"title":"Unit Testing: What is it and why do you need it?","tags":["Unit Testing","QA","Testing"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.5037593984962405,"src":"/static/6327467722c4e2f8951e626f58fbf29f/58556/unit-testing.webp","srcSet":"/static/6327467722c4e2f8951e626f58fbf29f/61e93/unit-testing.webp 200w,\n/static/6327467722c4e2f8951e626f58fbf29f/1f5c5/unit-testing.webp 400w,\n/static/6327467722c4e2f8951e626f58fbf29f/58556/unit-testing.webp 800w,\n/static/6327467722c4e2f8951e626f58fbf29f/99238/unit-testing.webp 1200w,\n/static/6327467722c4e2f8951e626f58fbf29f/7c22d/unit-testing.webp 1600w,\n/static/6327467722c4e2f8951e626f58fbf29f/f8fd9/unit-testing.webp 5472w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Sudhanshu Pandey","github":null,"avatar":null}}}},{"node":{"fields":{"slug":"/engineering/snapshot-testing-using-nightwatch-and-mocha/"},"html":"

Snapshot Testing

\n

Snapshot tests as the name implies, is a very powerful tool to test whether you the UI has change or not. A typical snapshot test case for a website/mobile app renders a UI component, takes a snapshot, then compares it to a reference snapshot file stored alongside the test.

\n

Snapshot Testing Benefits

\n

For QA Manual And Automation

\n\n

For Developer Unit Testing

\n\n

Need to install NPM

\n
    \n
  1. npm i mocha
    2. \n
  2. npm i clean-html
    3. \n
  3. npm i snap-shot
    4. \n
  4. npm i jsdom
    5. \n
  5. npm i jsdom-global
    6. \n
\n
\n

NightWatch does not have snapshot feature. So, We will use mocha to take snapshots. But Mocha will be run by NightWatch.

\n
\n

Directory Structure

\n

As per over automation project. We have created a \"snapshot\" folder under the \"test\" folder and we will be following the same structure as per the below project menu bar.

\n

\"N|Solid\"

\n

We also need to add Mocha test files, which will use to take snapshot and store under the root folder \"__snapshots__\".

\n

\"(https://cdn.filestackcontent.com/XGkI0wDrQoGDSp2djINg)\"

\n

If you are running automation code via visual code editor, then you can setup a launch.json file which helps you to debug your test code with all file/individual file.

\n

You can see the settings below of the launch.json file.

\n

\"(https://cdn.filestackcontent.com/qDjAHwHIQtKp2hmBdaEn)\"

\n
\n

Update Snapshot

\n

After creating a snapshot, sometimes we need to update snapshot due to improvement, customer requirements, and any valid changes on UI. So here, we can have some other settings which will help us.

\n
    \n
  1. \n

    If we want to update all snapshots by single command then we need to follow below instruction.

    \n

    Create a root folder file(update_snapshot.js) and paste code on it.

    \n
    (function(){\n      process.env.UPDATE\\=1;\n})()
    \n

    Add in package.json

    \n

    \"(https://cdn.filestackcontent.com/TTvchMDTW6F5x87J0688)\"

    \n
    2. \n
\n
\n

We can update all snapshot by using → npm run snapshot-u

\n
\n
    \n
  1. If we want to update the single snapshot then we can use the above technique but we just need to update the file name against \"test/snapshot\".
    2. \n
  2. \n

    If we use vscode, then we need to update launch.json as per above information

    \n

    \"(https://cdn.filestackcontent.com/uWX0pIUaSzKFyVKJGIYB)\"

    \n

    and need to create a file(\"snapshot.config.js\") in the root folder and paste the below code.

    \n

    \"(https://cdn.filestackcontent.com/Hh3PNxKmSo2pSFRA9YeM)\"

    \n
    3. \n
\n
\n

Important-: If we want to run only a snapshot test then we will need a small change in the nightwatch.json file.

\n
\n

\"(https://cdn.filestackcontent.com/EkBrPZffRv2ElZ0Qez36)\"

\n

You can find the complete reposrtory link here

\n","frontmatter":{"date":"July 29, 2020","updated_date":null,"title":"Snapshot testing using Nightwatch and mocha","tags":["QA","Nightwatch","snapshot-testing"],"coverImage":{"childImageSharp":{"fluid":{"aspectRatio":1.7699115044247788,"src":"/static/858d55e4f691f5e5780be7675877f12d/58556/snapshot_nightwatch.webp","srcSet":"/static/858d55e4f691f5e5780be7675877f12d/61e93/snapshot_nightwatch.webp 200w,\n/static/858d55e4f691f5e5780be7675877f12d/1f5c5/snapshot_nightwatch.webp 400w,\n/static/858d55e4f691f5e5780be7675877f12d/58556/snapshot_nightwatch.webp 800w,\n/static/858d55e4f691f5e5780be7675877f12d/99238/snapshot_nightwatch.webp 1200w,\n/static/858d55e4f691f5e5780be7675877f12d/135cd/snapshot_nightwatch.webp 1280w","sizes":"(max-width: 800px) 100vw, 800px"}}},"author":{"id":"Nitesh Jain","github":"niteshjain1987","avatar":null}}}}]}},"pageContext":{"tag":"QA"}},"staticQueryHashes":["1171199041","1384082988","2100481360","23180105","528864852"]}