Tag: agile testing

My experience as a Panel speaker @LeadDev webinar

Nishi Grover GargLeave a comment

I was invited by @LeadDev organisation to be a part of a webinar where we had a panel discussion on “Building a better testing culture“. I was elated to be a part of this great group pf panelists alongside Thayse Onofrio from Thoughtworks and Marcus Merrell from Saucelabs. We had a spirited and interesting discussion and shared some meaningful ideas on the topic. I would also like to thank our host Amanda Sopkin for her really on-the-nail questions and for directing the conversation, and our organiser Olivia Christian for inviting me and for her support throughout the event!

The webinar panel was live, lasted for 45 minutes and then we had some time for Q&A. There were some great questions and discussions over the LeadDev slack channel as well.

Here is a bit more insight into the event-

The world of software testing is changing under the pressure of ‘speed to market’. The pressure to quickly get products to market means we are starting to see a significant shift towards automated tests during development. This will likely cause socio-technical complexities for orgs and teams currently involved in testing.

In order to be successful through these changes, orgs will need to have a clear strategy and processes in place that will ensure testing is a vital part of the delivery process. In this new age of testing, how can engineering leaders prevent pitfalls such as friction between teams, a culture of blame, and outdated processes?

In this panel, we examined how shift affects traditional testing set-ups, covering what a healthy testing culture looks like and how to avoid the anti-patterns that lead to uncommunicative teams and project bottlenecks. We explored how engineering teams can best work together and how to encourage a shared vision of quality and the importance of efficient and effective tests.

Key takeaways

  • Define clear roles and responsibilities for quality and testing in your org 
  • Encourage QA to be seen as necessary, rather than inhibiting release times 
  • Understand which tests to automate, and which to not

About LeadDev

LeadDev is a community of software engineering leaders that come together to learn and get inspired on all things team, tech, process, and personal development. 

LeadDev has become an essential destination for anyone in tech and engineering who wants to scale themselves and create impact. They provide a range of content that includes articles, thematic content series, video talks and panel discussions, written and delivered by the best voices in engineering.You can register a free LeadDev.com account to gain access to our free engineering leadership content, free online events and our weekly email newsletter. 

Advertisement

I am Speaking @ LeadDev Webinar Panel – Dec 14th

Nishi Grover GargLeave a comment

I am super glad to announce that I have been invited by the LeadDev team as a Panel speaker in the upcoming Webinar on “Building a better Testing culture”

The webinar will be held on 14th December at 10.15 PM IST. Details for registration can be found here https://leaddev.com/events/building-better-testing-culture

I am thrilled to be a part of this amazing group of panelists and chat about building amazing teams and a great team culture in this new age of testing. We will be covering what a healthy testing culture looks like and how to avoid the anti-patterns that lead to uncommunicative teams and project bottlenecks!

To top it all, this is a free event!! So, you can register a free LeadDev.com account to secure your place. Not only this, your account will give you access to our free engineering leadership content, free online events and our weekly email newsletter. 

Register here now to attend this awesome event and become a part of this amazing LeadDev Community!

See you there!

How to Decide if You Should Automate a Test Case

Nishi Grover GargLeave a comment

Test automation is imperative for the fast-paced agile projects of today. Testers need to continuously plan, design and execute automated tests to ensure the quality of the software. But the most important task is to decide what to automate first.

In my article published on the TestRail Quality Hub, I have compiled & shared a list of questions to help you prioritise what you should automate next and guide your test automation strategy.

Here is a checklist of questions to ask yourself as you decide on automating a Test Case–

*******

Is the test going to be repeated?

Is it a high-priority feature? 

Do you need to run the test with multiple datasets or paths? 

Is it a Regression or Smoke Test?

Does this automation lie within the feasibility of your chosen test automation tool?

Is the area of your app that this is testing prone to change?

Is it a Random Negative Test?

Can these tests be executed in parallel, or only in sequential order?

Are you doing it only for the reports?

********

For the detailed explanation of each of these points, read the complete article here –>

Are your Test cases really effective?

Nishi Grover GargLeave a comment

Test teams are forever designing and adding new tests, running them, and reporting results. But is your test team creating tests that are effective at finding real problems?

How do you know if your tests are actually working, and not just adding to the ever-increasing test count?

In my article published on the Testrail blog site, I discuss some ways you can gauge the effectiveness of your tests — and improve them.

Defects Found

The top and most obvious indicator of the effectiveness of your test cases is the defects you find when executing them. As you and your team execute the designed test cases, constantly ask yourself these questions:

  • Are these tests guiding me toward defects?
  • Am I finding problems with the predefined test cases? Or do I have to do more exploration before even getting close to a problem?
  • Are these tests exercising unique flows or use paths?

Metrics

You can also look at your defect lists and find related test cases for the defect logged (if you have that ability in your defect management system). This interlinking helps the team understand what test cases led to the issues found.

You can then further analyze whether that test case was created during test design or later added to the list when the issue was found.

Exploration

If your test cases are not effective, you will not find any useful bugs in test execution. That will mean most of your time is spent in unplanned exploration or ad hoc testing. So, by looking at the time spent in actual test execution versus the time spent on ad hoc testing, you can figure out the effectiveness of the test cases you designed.

If your test cases are effective, you will find issues, explore more use paths, navigate through different integrations with other features, and test different aspects of the same functionality.

If at the end of your test execution, you feel that you have not done all of that, you can infer that is because your test cases might be too simplistic or obvious, and therefore not effective enough to find any useful bugs.

History

Continue Reading here–>

3 Ways Technical Debt Can Actually Help Improve your Sprints

Nishi Grover GargLeave a comment

“Debt” is not a pleasant term. It brings to mind a burden and generates a feeling of anxiety. The same may also be true for technical debt, or the extra work that we incur while developing our software in the form of missed quality targets, pending tasks, or skipped points from our exit criteria checklists. Like monetary debt, technical debt happens when we make a decision that is quicker in the short term but will hurt us in the long term.

Though we may try our best to limit this debt, it will still happen. And while we will need to pay back the debt one day, we can also use it as a lesson to help improve ourselves and our processes. If it ultimately helps our development, it doesn’t even always have to be a bad thing.

In my article published on the Ranorex blog site, I examine three ways technical debt can actually help us improve our sprints.

Better Estimation

Though the first time incurring technical debt due to an inability to complete an activity as planned may not be pleasant, it should consequently improve the team’s estimation and planning.

Let’s say we had defined developers’ tasks for all user stories with estimated hours, along with a mandate of peer reviews being performed for all code being written. But the end of the sprint saw that though the developers marked their development tasks as done, none of the code had been peer reviewed before check-in. It could have happened due to lack of time or ownership.

The next sprint, the team then decides to have a separate sub-task for peer reviews under the development tasks, each of which is assigned to a peer with an allotted time of 30 minutes. This helps the team plan, have clarity around what tasks are pending, and see how much effort is being spent on the tasks.

So, even though you may begin to accumulate technical debt early on in your sprints, understanding the cause and having a plan of action may improve the team’s overall performance.

Sequencing and Prioritizing

If you find yourself at a point where release is a couple of sprints away and you have a number of unresolved defects, even though they are lower severity, the team may decide to reduce open defect counts for a sprint rather than adding new features. The technical debt incurred in the form of defects can urge the team to refocus and shift priorities.

Or, let’s say your team agreed to 70% automation of regression testing in the beginning of the release cycle, but after four sprints, the scripts they created are showing signs of being unmaintainable or not scalable enough. This may affect delivery in the end, so some testers may take the call of focusing full time on reworking the scripts and adding new automated tests to them, while the other testers take up functional and regression tasks.

My team once found out at the end of our fifth sprint that our developers had not been performing static analysis of their code or creating the reports that were mandated for every sprint. Whatever may have been the reason, this meant that running those reports now was leading to hundreds of errors or warnings all pertaining to code formatting, naming conventions and comments. Even though these were minor issues, it required time to get them all corrected with thousands of lines of code.

Read More »

Achieving the Goal of In-Sprint Test Automation

Nishi Grover GargLeave a comment

Getting test automation done is a challenge, especially within the tight deadlines imposed by Scrum. As much as the thought of continuous in-sprint test automation sounds enticing, the practicality of it may elude most Scrum teams.

In my article published here– I look at some of the main things you need to consider in order to get your test automation done within the confines of your sprint.

Framework

The first thing to focus on is a framework that is useful, is easy to understand, and helps all stakeholders participate in test automation.

This is essential because you want to make test automation a continuous activity that is a part of daily work, not a once-a-sprint (or once-a-release) work item. For this to happen, the framework must make it equally comfortable for a businessperson, developer, functional tester or automation expert to add their contribution and see the results of their efforts.

There are many business-friendly frameworks and techniques, like behavior-driven development (BDD), as well as many tools that can create tests in a domain language and then translate them to script code.

All stakeholders must be trained on using the framework, and their area of contribution must be made clear to them, with practical hand-holding. The automation tester can then focus on maintaining the framework, generating test suites and editing failing scripts, while the creation of test automation will be a continuous task assigned to everyone involved.

Collaboration

The next thing to focus on is collaboration between the various stakeholders. A continuous automation framework can only survive when it is being fed and tended to by everyone on the team.

  • The business people, like a business analyst or a product owner, can help by adding user scenarios or defining the requirements in a framework-friendly format. This may require them to be trained on the preferred format based on the framework being used
  • The developers can help by creating reusable methods for steps of the script. They can also create and maintain an object repository for all elements they add to the UI while testers use the pseudo names of the elements in the test scripts. This means that the scripts can be created before (and independent of) the application UI, and such scripts won’t need editing when the UI changes, as long as the object repository is kept up to date
  • The testers can help by adding more scenarios, specifying and creating test data, and executing the scripts periodically

Strategy

How to strategize the development of test scripts is crucial to making in-sprint automation a reality. Using API-level automation whenever possible will reduce the time and effort.

Continue Reading –>

Read More »

10 Lessons When Moving from Waterfall to Agile

Nishi Grover Garg1 Comment

Many organizations take up the transition from waterfall to agile with the best intentions in mind. Like so many other companies, you might also be seeking to replace your traditional waterfall processes with agile in a quest to shorten the time-to-market and deliver high quality applications.

The road to agile, though, can be a rocky one! That’s why, in my latest refresh post for Ranorex blog, I have put together a few lessons and tips that will help you in succeeding in moving from waterfall to agile successfully!

The article was published at https://www.ranorex.com/blog/10-lessons-when-moving-from-waterfall-to-agile/

Here is a quick list of lessons we dive into-

1: Embrace the agile culture first

2: Adapt roles and responsibilities

3: Take a whole-team approach

4: Test early and often

5: Remember that agile is iterative

6: Encourage transparent communication

7: Make test automation your friend

8: Commit to early feedback and re-planning

9: Include the whole organization in the agile transformation

10: Adopt tools to enable team collaboration

Check out the complete article to read in detail about each of these learnings that can help you succeed in your agile transformation.

Cheers

Nishi

Read Along- ‘Agile Testing’ Chapter-21

Nishi Grover Garg2 Comments

“Key Success Factors”

Outlining some Key success factors for Agile Testing –

Success Factor -1 Use the Whole Team Approach

When the whole development team takes responsibility for testing & quality, you have a large variety of skills sets and experience levels taking on whatever testing issues might arrive.

Success Factor -2 Adopt an Agile Testing Mind-Set

Use agile principles and values to guide you. Always try the simplest approach first. Experiment with new practices, tools, and techniques.

Success Factor -3 Automate Regression Testing

Use Agile Testing Quadrants and test automation pyramid to help you automate different types of tests effectively. Experiment with different ways of getting support from management and from team members to start some tiny automation effort.

Success Factor-4 Provide and Obtain Feedback

One of the most valuable skills you can learn is how to ask for feedback on your own work. Feedback is imperative for agile teams.

Success Factor -5 Build a Foundation of Core Practices

Continuous Integration process needs to be implemented, setup test environments and manage technical debt

Success Factor -6 Collaborate with Customers

Help customers clarify and prioritize requirements, illustrating requirements with concrete examples and turning those examples into executable tests.

Success Factor -7 Look at the Big Picture

Testers tend to look at the big picture, and usually from a customer point of view, which is a big contribution to the team. Plan testing to cover all angles. Use Exploratory testing to learn more about how the application should work, and what direction your testing needs to take.

************************

And here ends my ‘Read Along’ Series for ‘Agile Testing’ by Lisa Crispin and Janet Gregory. It sure was a fun and informative read and I learnt a lot from it! I hope this series helps someone read along chapter-wise or even someone looking for quick introduction to agile testing.

Happy Testing!

Nishi

Read Along- ‘Agile Testing’ Chapter-20

Nishi Grover Garg1 Comment

“Successful Delivery”

  • It’s not enough to just code, test and say it’s done. Our goal is to deliver value to the business in a timely manner.

It is helpful to have a “Fit and Finish” checklist. Sometimes fit and finish items aren’t ready to be included in the product until close to the end. It may be necessary to rebuild parts of the product to include items such as new artwork, license or legal arrangements, digital signatures for executables, copyright dates, trademarks and logos.

It is helpful to assemble these during the last full development iteration and incorporate then into the product while continuous integration build cycles are running so that extra builds are not needed later.

  • Agile testers can serve as a conduit or facilitator when it comes to physical delivery of the software.
  • Most teams accumulate some technical debt, despite the best intentions, especially if they’re working with legacy code. To maintain velocity, your team may need to plan a refactoring iteration at regular intervals to add tests, upgrade tools and reduce technical debt.
  • Some teams resort to ‘hardening’ iterations, where they spend time only finding and fixing bugs, and they don’t introduce any new functionality. This is a last resort for keeping he application and its infrastructure solid. New teams may need an extra iteration to complete testing tasks, and if so, they budget time for that in the release plan.

I, too, have worked with Hardening Iterations and here is the article I wrote a while back about it https://testwithnishi.com/2018/10/08/optimize-your-hardening-sprint-for-a-quality-advantage/

End Game

It is the time when the team applies the finishing touches to the product.

It is not meant to be a bug-fix cycle, because you shouldn’t have any outstanding bugs by then, but that doesn’t mean you might not have one or two to fix.

  • Use the end game to do some final exploratory testing. Step back and look at the whole system and do some end-to-end scenarios.
  • As a part of the end game, your application should be deployed to staging just like you would deploy it to production.
  • Staging environments can also be used for load and performance testing, mock deploys, fail-over testing, and manual regression tests and exploratory functional testing.
  • Automating data migrations enhances your ability to test them and reduces the chance for human error.
  • Last minute disasters can happen. The team should cut the release scope if the delivery date is fixed and in jeopardy.
  • Work to prevent a “no go” situation with good planning, close collaboration, driving coding with tests, and testing as you code.
  • As a tester, it is important to understand how customers view the product, because it may affect how you test. Alpha and Beta testing may be the only time you get to interact with end users, so take advantage of the chance to learn how well the product meets their needs.

Learn from each release and take actions to make the next one to go more smoothly.

Read Along- ‘Agile Testing’ Chapter-19

Nishi Grover Garg1 Comment

“Wrap Up the Iteration”

  • Agile team delivers working software at the end of the iteration – demonstrate to the customers and get their feedback.
  • Having testers conduct the ’Iteration Review’ is a common practice as they’ve usually worked on all the stories. The Scrum Master, programmers or testers could demonstrate the new features – It is recommended to rotate this honor.
  • Retrospectives are an excellent place to start identifying what and how you can do better.
    • Start, Stop, Continue technique – Discussing What went well, What did not go well and what we can start doing to help.
    • Write task cards for actions to be undertaken to implement the steps
    • At the end of the next iteration, take a checkpoint to see if you improved

Retrospectives are a simple and highly effective way for teams to identify & address issues. The retrospective meeting is a perfect opportunity to raise testing-related issues. Bring up issues in an objective, non-blaming way.

Celebrate Successes

Make sure your team takes at least a little time to pat itself on the back and recognise its achievements.

Even Small Successes deserve a Reward.

Many agile teams have trouble taking time to celebrate success.

Have a weekly fun gathering or team games.

  • For big milestones such a big release or achieving a test coverage goal, the whole company can have a party to celebrate, bringing in catered food or go out.
  • It is also important to celebrate individual successes. A ‘Shout-Out Shoebox’ – is a great idea to recognize the value different team members contribute.
  • Taking time to celebrate successes lets your team take a step back, get a fresh perspective, and renew its energy so it can keep improving your product, giving team members a chance to appreciate each other’s contributions. Don’t fall into a routine where everyone has their head down working all the time!
  • Take advantage of the opportunity after each iteration to identify testing- related obstacles, and think of ways to overcome them.