Articles

When it comes to application testing, many project managers and test leads do not routinely conduct performance and load testing early in the development lifecycle. Instead, they undertake performance, and load testing after the application is complete, at the point where functional testing is applied. In fact, in many organizations, the performance test is frequently the last step — almost an afterthought — conducted right before the application goes into production.

This approach creates a classic problem: late-stage testing. Whenever testers identify issues, developers must modify the long-finalized code to fix them. These code changes can impact other parts of the application, resulting in breaks. Addressing problems after-the-fact is time-consuming and expensive. Furthermore, any delay in releasing a new feature or a new app can directly impact revenue, competitive position, brand, and adoption.

Source de l’article sur DZone (Agile)

In the current technological era, it is normal to find 4-5 new Android-based apps uploaded to the Play Store every week. Seeing competitors deliver apps so frequently creates pressure to deliver quality apps in a short span of time. During this limited time, mobile application development and testing of the business’ purpose should be achieved. With this pressure, there is a need to automate certain processes which can save time while providing a trusted output.

That being said, mobile test automation can save a lot of time and is always preferred over the entire manual test execution process. With much less effort, the verification of frequent test cases that manual execution requires can be automated, and more effort can be diverted to new features of the application, which are vulnerable and tend to have more defects.

Source de l’article sur DZONE

As I’ve said in the past, it is super easy to build a VSTS Build (now Azure DevOps Pipeline) to keep two repositories in sync. In that article, one of the steps is pushing the new code to the destination repositories with a URL like https://$(token)@myaddress.visualstudio.com/DefaultCollection, to automatically include a token to authenticate in the destination repository.

Now, some of my builds have started to fail due to timeout and I immediately suspected the reason: the name change from VSTS to Azure DevOps changed the base URL from accountname.visualstudio.com to dev.azure.com/accountname, and this broke the build.

Source de l’article sur DZONE

When writing unit tests, it is common to initialize method input parameters and expected results in the test method itself. In some cases, using a small set of inputs is enough; however, there are cases in which we need to use a large set of values to verify all of the functionality in our code. Parameterized tests are a good way to define and run multiple test cases, where the only difference between them is the data. They can validate code behavior for a variety of values, including border cases. Parameterizing tests can increase code coverage and provide confidence that the code is working as expected.

There are a number of good parameterization frameworks for Java. In this article, we will look at three different frameworks commonly used with JUnit tests, with a comparison between them and examples of how the tests are structured for each. Finally, we will explore how to simplify and expedite the creation of parameterized tests.

Source de l’article sur DZONE

UI testing is an important part of quality assurance. Specifically, UI testing refers to the practice of testing front-end components to make sure that they do what they’re supposed to. If a user clicks the Login button, the login modal appears. If they click a link, they’re brought to the appropriate part of the application. With automation platforms, these individual tests can be linked together into workflows and automated. Business-driven development style tests can be created in this fashion. The UI can be tested to see that each individual path that a user may take is functional and that the interface is responding appropriately. Other platforms exist that allow these workflows to be tested on simulated resolutions and devices, ensuring that the user experience is consistent across all possible combinations of browser and device.

API testing lives a layer below UI testing. The UI is fed by these APIs and renders the DOM based upon conditions set by both the user and the developer. These conditions determine the sort of API call that’s made to populate the viewport. When we’re UI Testing, it could be argued that we are indirectly testing the API layer. It’s actually pretty fair to say so. Many of the actions that our UI platform will take will issue API calls. If the DOM rerenders correctly, we can assume to an extent that the API call was successful. The dangerous ground here is the assumption.

Source de l’article sur DZONE

The trends in software development are showing that more and more companies are adopting CI/CD methodologies to deliver their software applications. We all know that the market demands quicker releases. The days of waiting for months for new releases are gone. Software is now being released at record speeds! Adopting CI/CD does just that. It helps get your application out the door to the market as often as possible. However, one key aspect that seems to be overlooked is Continuous Testing. It’s great that CI/CD is getting software out quicker but quality should not be sacrificed. To solve that you have to test early, test often! Adding a culture of Continuous Testing to your model will provide the following benefits because now you’re focused on testing from the beginning of your SDLC

  • Faster Release Cycles
  • Better Code Quality
  • Better Test Coverage
  • Better Reliability

Now that we know to truly have a CI/CD methodology you need continuous testing as well. But just like adopting CI/CD, continuous testing requires an organizational culture shift. So how do you build that culture? It’s a different mindset that relies heavily on automation: Automated Unit Tests, Automated Functional and Non-Functional Tests, Automated Regression Tests, and Automated Deployments. Basically, anything that can be automated should be automated! That is the key principle of Continuous Testing, test from the beginning and automate as much as possible to ensure faster release cycles.

Source de l’article sur DZONE

DevOps has become more than a trend—it’s a survival imperative for the enterprise. In today’s digital economy, software innovation drives business innovation.  The faster developers can deliver on the next wave of software innovation, the faster the business can deliver customer value, bring new revenue streams online, and respond to market events. DevOps practices across the enterprise can deliver business results at the speed and quality customers expect.  

Many IT organizations start their DevOps journey implementing automation and tools only to quickly face hurdles when trying to scale DevOps practices across the organization.  Their journey starts to take a detour as they struggle with organizational boundaries, unwieldy system-wide processes, and cultural resistance to change. It’s common to blame the people and teams that are not getting on board, but to quote Edward Deming, “People work in the system, management creates the system.”

Source de l’article sur DZONE

Anyone who touches product development knows all too well the importance of QA. But what about those at the executive level?

CIOs and CTOs might have different priorities than their product development teams, but at the end of the day they should care about testing just as much as everyone who touches the software. That’s because properly managed testing — meaning testing that’s consistent, repeatable and occurs early and often — can actually speed time to market and prevent buggy software. As a result, the right testing strategy can increase revenue, drive innovation and prevent costly mistakes.

Source de l’article sur DZONE


CI Builds Status

We all know the practice of continuous integration.

One of the common pitfalls of CI is that the build status is not monitored and not treated as one of the top priorities for the team.

Source de l’article sur DZONE

I use a shell every day. Almost always, I want to repeat a previous command, or repeat it after a slight modification. A very convenient way is to use arrow-up to get the most recent command back. Another common trick is to type ctrl-R and incrementally search for a previously used command. However, there are two other tricks for repeating previous commands that I use all the time, which are not as well known.

Escape-Dot (or !$)

Often, you want to repeat only the last argument of the previous command. For example, suppose you want to run git diff path/to/tests, and then git add path/to/tests. For the second command, you can type git add escape-dot (escape followed by a period), and it gets expanded to path/to/tests (the last argument of the previous command).

Source de l’article sur DZONE