Category: Continuous Testing

Continuous testing is the process of executing automated tests as part of the software delivery pipeline to obtain immediate feedback on the business risks associated with a software release candidate.

  • TestPlant and Undo partner to deliver superior continuous integration testing

    London, UK – August 17, 2016 – TestPlant, the maker of the eggPlant range of software quality tools, today announced a technology partnership with Undo. The partnership will see TestPlant’s flagship test automation tool,eggPlant Functional, integrated with Undo’s record, rewind and replay technology, allowing developers to identify, diagnose and respond to the failures that continuous integration misses.

    Continuous integration makes regressions easier to fix by notifying developers that their test has failed but finding the failure’s origin isn’t always a simple process. Undo enables Linux and Android developers to see exactly what their program did at every step in its execution so that developers can respond quickly to failures in continuous integration environments, increase their debugging productivity and improve software quality.

    eggPlant Functional helps companies test their applications better, faster, and with less effort by automating the execution of functional testing. When integrated with Undo’s latest product, Live Recorder, eggPlant users can generate complete records of their program’s execution in a highly optimized way, capturing failures in their entirety but with minimum resource usage. These recordings can then be debugged offline and shared among developers who can collaborate on resolving the most pressing software issues.

    “When a test fails, our technology captures an exact replica of the failure as it occurred and automatically sends that recording to the development team for analysis,” said Greg Law, CEO and co-founder of Undo. “This cuts out the effort involved in thinking about where an error lies, permits QA and engineering to communicate clearly as the recording captures all the information necessary to fix the problem, and reduces the time, stress and cost associated with finding and fixing bugs.”

    Ideally suited to continuous integration environments and companies undertaking digital transformation projects, eggPlant Functional uses a patented image-based approach to GUI testing that allows it to interact with any device by looking at the screen, in the same way a user does.

    “Testing is vital to the success of continuous integration, and enhancing eggPlant’s capabilities with Undo’s technology provides developers with the ability to rapidly respond to failures in production and test environments,” said Antony Edwards, CTO, TestPlant. “With this integration, we are providing Linux and Android developers with the ability to increase their debugging productivity by at least 50% and significantly improve software quality.”

    About TestPlant

    TestPlant is an international software business based in London. It has development centers in the USA and the UK with sales and support centers in the USA, the UK, Germany, China and Japan as well as an extensive network of business partners. TestPlant’s products are used in over 40 countries by well over 350 enterprise customers in sectors which include Financial Services, Automotive, Healthcare and Life Sciences, Media and Entertainment, Retail and Defense and Aerospace. The eggPlant range is a set of tools which supports the design, development, test and management of software applications for mainframe, desktop and mobile use in any technology platform environment. The tools are relevant in agile, mobile, web and DevOps deployments. eggPlant use improves and reports on the quality and responsiveness of software systems, reduces time to market and lowers costs by introducing process automation. The eggPlant tools have been granted patents in the USA and in Europe. TestPlant is a Red Herring Global Top 100 company, a Deloitte UK Technology Fast 50 and EMEA 500 business, a member of the Sunday Times Hiscox Tech Track 100 and is the recipient of three Queen’s Awards for Enterprise. The Carlyle Group is a major investor in the company. www.testplant.com

  • First-Time Quality for Software on a Blockchain Network

    First-Time Quality for Software on a Blockchain Network

    There is probably more trust in the world today than at any other point in history—not necessarily by choice, but because of our use of software to carry out almost every type of transaction. The use of blockchain networks brings visibility to those networks of transactions: Information about an asset that was once held by separate owners is changing to the lifetime history of an asset or transaction and is shared between all stakeholders.

    For software developers, this means ensuring the integrity of a blockchain network is paramount. To that end, three key interesting aspects regarding continuous testing are emerging:

    • New approaches to business networks require the ability to test supply-chain business processes and transactions.
    • Reliance on shared technology ecosystems requires the ability to test APIs from multiple perspectives and to simulate the behavior of consensus.
    • Increased dependency of APIs requires the ability to test integrations at scale without affecting distributed ledgers in which any interaction is immutable (unchangeable) and final.

    Project teams face an unprecedented demand for first-time quality while minimizing the impact of testing on the team’s delivery. To respond to this challenge, test teams are enhancing their capabilities so they can test:

    • Apps that integrate with a blockchain network;
    • Chaincode that manages the execution of transactions on a blockchain network; and
    • Provision and scalability of a blockchain network.

    In addition to these new capabilities, proven continuous testing techniques and tools can be adopted to help the team deliver quality software into their blockchain ecosystem.

    Test Entire Ecosystems

    Using a blockchain network means an organization is redefining the structure of its business networks and processes, connecting distributed supply chains with a single transaction backbone. Projects need testers to minimize the risk of business disruption by validating every business process works across all stakeholders on the blockchain network.

    Test State Early—Shift Left

    In a blockchain ecosystem, the new paradigm is state-based communication, not message-based communication. The behavior of the state of an asset is influenced constantly by market, internal and regulatory changes, so projects increasingly are adopting Agile and DevOps practices to respond as quickly as possible. Shifting testing to the left on an Agile project means the team can test early, and those tests can then be reused continuously. Providing early, iterative feedback on quality at the time of development means fewer problems are found late in the life cycle, where their business impact can be severe.

    Establish Technical Trust

    One of the great things about blockchain technology is the potential to create greater transparency throughout an ecosystem.  Trust is embodied in the transaction itself, which gives an important new role for digital systems of trust. Regulators and owners of a blockchain network must ask testers to validate the codification of contracts, compliance and certifications, which are then deployed into the blockchain network and embodied within the business transactions.

    Use of blockchain technology will fundamentally change business processes and enable new opportunities. Success depends on the level of trust stakeholders have in the blockchain network and the blockchain ecosystem.

    However, a blockchain ecosystem is an environment shared among different organizations, each of which has a stake in—and dependence on—the overall system. This means each organization must trust the other stakeholders to fully test any software that interacts with the blockchain ecosystem in a manner that will not impact the reliability of the overall system. As such, a blockchain ecosystem that has a culture and reputation of technical trust between the dependent stakeholders is more likely to be successful. Continuous testing brings trust throughout the blockchain ecosystem.

    To establish technical trust in a blockchain ecosystem, ensure these four key things:

    1. Your team can test when needed, not just when possible.
    2. Required technical environment works as required to support the business flows.
    3. Business processes and transactions run as expected.
    4. Solution scales to the expected usage.

    Benefits of Continuous Testing and ‘Shift Left’

    Enabling teams to shift testing to the left means projects can test when needed, not just when possible. Continuous testing means an organization can deliver capabilities faster, respond quickly to ongoing changes and realize the value of transforming applications to utilize the power of a blockchain network.

    Watch the webinar replay on how to implement quality checks as early as possible, run tests as often as possible and integrate automated testing with release management to minimize the complexity of deployment.

    About the Author / James Hunter

    James Hunter jpg

    James has spent a large part of his career architecting and implementing large-scale, distributed systems in the finance, public and defense sectors. He now leads a global business segment responsible for defining technology strategy then developing and implementing solutions for both IBM and clients. Mentoring and encouraging future technical leaders is important to James. He works with students of all ages and speaks in primary schools to universities to evangelize on the benefits of technology and the positive impact software can have on our society and the environment. He has a degree in Management Systems and he is a Chartered Fellow of the British Computer Society. Connect with James on LinkedIn/Twitter

     

  • Cobalt Merges Bug Bounties, Continuous Testing for Better Security

    Cobalt Merges Bug Bounties, Continuous Testing for Better Security

    The rapid pace of application development today can be hard to keep up with, especially when it comes to security. Combining the benefits of continuous testing with the incentives of a crowdsourced bug bounty program seems like a potentially effective way to address that volatility effectively.

    Companies need to keep up with demand while staying one step ahead of the competition. It’s very easy in such a dynamic environment for security to fall through the cracks, or be ignored entirely. Combining DevOps-style automation with crowdsourced intelligence is a good approach.

    Bug bounty programs have matured and gained mainstream acceptance in recent years, thanks in large part to the leading champion of bug bounty programs, Katie Moussouris. After launching Microsoft’s successful bug bounty program, she left to join Hacker One as Chief Policy Officer. She recently ventured out on her own as a bug bounty evangelist and consultant under the banner of Luta Security.

    The concept is simple: Rather than pretending vulnerabilities don’t exist, or sitting around waiting for the bad guys to exploit the vulnerabilities first, a bug bounty program provides financial incentives for hackers and/or security researchers to identify and report flaws. The net result is a win-win-win that results in more secure applications, happier customers and satisfied security researchers who feel appreciated—and paid—for the work they do.

    That is where Cobalt comes in. “I’m impressed by how Cobalt has built its model by taking the best elements from the bug bounty space, which offers rewards to those in the security community who can identify software vulnerabilities, and combining them with a scalable, continuous penetration testing platform,” said Robert Fly, an investor and advisor with more than 15 years of application security experience from Microsoft and most recently Salesforce, where he built the product security team and was VP of Security Engineering.

    “Companies building web and mobile applications need the flexibility to quickly develop new applications that delight their customers, while ensuring that their applications are secure,” said Jacob Hansen, CEO of Cobalt. “Instead of needing to invest in security tools, such as scanners and penetration tools that are expensive and vary in quality, and having to hire security staff or consultants, our customers rely on Cobalt to provide transparent continuous application testing services, leveraging a powerful platform along with a global community of security researchers.”

    There are a variety of well-known software-as-a-service (SaaS) companies already using Cobalt, including GoDaddy, Wix, Weebly, Nexmo and Optimizely.

    At face value, this seems like an awesome strategy. Only time will tell how it really plays out, but the success of bug bounty programs when it comes to finding and fixing vulnerabilities in general is indisputable, and continuous testing is a staple of DevOps environments. Combining the two should raise the bar for application security in general.

  • DevOps Chat: John Harris, LeftShift on DevOps Consulting and Continuous Testing

    DevOps Chat: John Harris, LeftShift on DevOps Consulting and Continuous Testing

    This episode of DevOps Chat has us speaking with John Harris of LeftShift IT. LeftShift is based in London, but has customers the world over. He speaks with us about DevOps consulting and continuous testing. John has some great insights to share that I think you will find interesting.

     

    Alan Shimel:                Hi, everyone. Alan Shimel – devopsy.kinsta.cloud here for another DevOps chats. This episode’s guest is John Harris of LeftShift IT. John, welcome.

    John Harris:               Thanks, Alan. Good to be here.

    Alan Shimel:                Thank you. So John, what exactly is your role with LeftShift 

    John Harris:               My role is the Head of Continuous Delivery in DevOps with LeftShift.

    Alan Shimel:                Okay. And John, you know what? Some people in our audience are probably not familiar or may have not heard of LeftShift IT before. Why don’t you give us quickly a background of LeftShift?

    John Harris:               Yeah. We’re primarily a services consultancy in the continuous delivery – DevOps continuous testing space. We work quite a lot with IBM, a lot of other different vendors. Based in London and the UK, but we have a lot of our business offices based in the U.S. as well.

    Alan Shimel:                Sure. And John, before we jump into the subject of today’s chat, which is around continuous testing, I want you to take a moment and just talk about this burgeoning field of DevOps consulting. It seems to be exploding. I was in London for the DevOps Enterprise Summit last month and I was absolutely blown away with the diversity of firms from big to small that are offering DevOps consulting services. How long has LeftShift been in the DevOps consulting space?

    John Harris:               We’ve been in the area kind of on and off I guess you could say ten years. I guess most people would say DevOps has only been around since that original kind of DevOps coining days again in Belgium, but I guess a lot of people say the discipline itself had been around before the name, so I guess the processes around DevOps you could say we’ve been involved in for quite some time I guess. 

    Alan Shimel:                Sure. And John you know I don’t think we would be seeing this explosion of DevOps consulting if there wasn’t a wanting audience for DevOps consulting continuous delivery consulting services. Is that pretty much what you’re seeing with LeftShift? I assume business is good.

    John Harris:               Yeah. It’s one of those interesting areas where one of the things I guess the DevOps consultants could say is you don’t just want to create a new DevOps practice in your company. You don’t just want to bring in these pieces, but it’s a difficult loop because you’ve got to then support those processes and you’ve got to get that knowledge into the organization somehow, so I think our model is firmly to go and help people get started and gussy up their own practice and their own good processes and then kind of lead them to it, so yeah absolutely.

    Alan Shimel:                Got it. So John, let’s pivot a little bit here and talk about continuous testing. So, I will tell you that on devopsy.kinsta.cloud the whole notion of testing, continuous testing, automated testing is one of the most hotly debated and in some ways controversial topics within DevOps. Wondering if you see similar?

    John Harris:               Yeah. I think so. I mean I think traditionally in so far development, testing has traditionally kind of been seen as just the necessary part that you have to do at the end, but I think now that continuous delivery is becoming a real discipline and people are being forced to go faster and faster for getting ahead of the market and things like – can’t afford to see testing as a poor cousin of development anymore and I think testing is really becoming – people realize I can throw stuff out into production as quick as I want really, but actually it’s throwing it out with the quality that it needs to – that product to still be viable in the market. So I think absolutely. The drive towards testing is long overdue, but it’s definitely getting started. 

    Alan Shimel:                Got it. And John, can you have continuous without the automation though?

     John Harris:               Personally I don’t think so. I think that DevOps really – one of the biggest buzz words for me – DevOps and continuous delivery is really the organization. I think you have to have the process behind it, but I think when you go towards anything delivering more rapidly through all of these stages in our development life cycle in production, I think you just cannot scale at the size that we need to in order to get that stuff out without automating the process.

    I mean when you talk about the union it forms like Netflix and Etsy and all of those guys, now three, four years ago, there’s no way you can deliver that kind of scale without putting in the automated tool in and also the processes and the culture around that to enable that to where it will have the effect that you need.

    Alan Shimel:                Sure. So John, I think one of the controversy – not controversy, but one of the big discussion points around this though is what does this mean for the traditional Q/A role and for the people in the Q/A space?

    John Harris:               Yeah. I think teams have traditionally kind of been split. I mean obviously we have these silos and DevOps as kind of trying to address the silos of development and testing and ops and those kinds of things. I think again, testing’s one of the things that gets left out of that, but certainly in the customers that we work with, we’re seeing a lot of Q/A teams being retrained in certain ways, brought into the development side of the organization, having their practices changed to more of a development software engineering kind of way of working.

    We’re certainly seeing some of the geographic splits that have been traditional in this area kind of being broken down, perhaps testing, quite a lot of off shoring work in testing. Some of that’s coming on shore. Testers are becoming more technical but yeah, retraining and the different skills required now for the Q/A role, to bring that into more of a technical automation. That’s certainly a question a lot of our customers are grappling with right now and I think the decisions they aren’t just technical, but they go into the culture side of the company and how the company has organized itself. So yeah, it is a contentious area. I agree.

    Alan Shimel:                Yeah. It certainly is and it’s really one of those – for people in the Q/A space, it’s a pocketbook issue, right? They perceive a threat to a livelihood, even though I don’t think that’s the case. I think it allows them actually to soar and higher and do bigger and better things, but there’s certainly that element to it.

    John, I want to talk for a moment about service virtualization and we actually have a webinar coming up on I think it’s August 23rd where we’re going to looking at a real unicorn company – Mertz Shipping Lines, which is I think is 80 years old or something in traditional shipping, not what you would think of as your Google, Facebook kind of company. But they’re going to be talking about service virtualization, shifting left. Thoughts on that at all?

    John Harris:               Yeah. Service virtualization is an area that we work with quite a lot, especially around the IBM tool set. And yeah, Mertz is doing great work. Almost all of the organizations that we work that are trying to do some kind of parallel development, I mean one of the patents that we see is building the y and Rex API layers on top of some of their legacy – so business services and things like that and they want to do some parallel development with the ____, with the Rex, with the user in space layers. So SV’s really able to give those teams a really solid platform because everything’s based on their service interface definitions and it can really do some proper parallel development there and we’re seeing some great shifts left with those development teams and actually the ability to identify a whole bunch of defects before they would even go and integrate with each other.

    I think we had one team who identified over 100 defects in the early testing stages using service virtualization before they even would have integrated with the other services. They were able to get those fixed even before they went into their next integration environment, so that was a really great success story – service virtualization. 

    Alan Shimel:                Yeah, absolutely. I think I interviewed the Mertz guys at Interconnect last year and it was an interesting case study. I guess we should mention – there is a Service Virtualization for Dummies book that people can download and I don’t have the URL in front of me. I’ll try to include it in our notes. I think it comes out from IBM for people who are interested in this. But John, let’s return – what do you see – what in your role with LeftShift, what do you see as sort of the next frontier where the – not the battle, but where there are points to be made, where there are battles to be won for lack of a better word in the near term future?

    John Harris:               I think the biggest one really and we’re starting to see the shift now, but it’s still early stages and the custom is that – for the unicorns and the startups, this is probably not going to be a big bull, but certainly for enterprise – user interface testing is still very prevalent and we talk about the testing pyramid how most of our tests are one of the unit tests and then we’re gonna have a good base of integration tests and then a small percentage of UI test if you want.

    I think currently a lot of our organizations have one of them that’s flipped on its head because it’s easy to do UI testing and reason about it going to the business, but now when we go faster, I think the traditional focus on UI testing is going to have to go away, but when we talk about APIs on top of everything and things like the API economy and a lot of systems now just don’t have UIs. Coming out with a lot of systems that are all API driven and smart devices.

    I think everything’s going to have to be integration tested. I think the APIs and the logic behind them is really where the core business functionality is, so I think that’s where the importance is gonna be and it’s going to be moving organizations and showing them that integration testing and API testing is not the way to go and obviously automating that as part of their delivery pipeline, which is sometimes a little more difficult to do on the UI side.

    Alan Shimel:                Yeah. Quick question on that because I thought about how to deal firsthand with this issue. Shouldn’t the API testing – at least the tests themselves come from the same people who are writing the API? In other words, where’s the burden? Should the people who are providing the APIs also provide the testing for it or is that sort of letting the wolf in the chicken coop, right? Where you’re using someone else’s API. The burden is on you to make sure that that is in fact working with your system.

    John Harris:               Yeah. That’s a really interesting point I think and there are different kind of philosophies around it. Myself, we work a lot with the virtualization and the testing side of it, so we would say that if you’re developing the interface then you’re also in charge of developing the basic virtual service for that to integrate with your consumers, but I’m very much on the side of consumers developing the API test or the APIs that you consume, because if you think about the case where I’m a consumer, I may not need every field in an API. I may just use a few if I’m developing loosely coupled micro services let’s say.

    So I’m really in favor of each team who consumes an API developing their own tests and then contributing those tests to the API team so they can be run as call, every build or every deployment. So then if I change functionality and those tests fail, I know which team gave those tests to me and I can go and alert them, “Well, look I’ve made a change and I’m just going to break your implementation or your call of this API, but I may not have broken anyone else’s.”

    I mean I think putting the burden to test every piece of functionality, especially as we go to more loosely coupled services is kind of an unreasonable burden on the team developing that API.

    Alan Shimel:                Got it. You know what, John? Believe it or not as I told you I think before we went live, time goes really quick on these and we’re coming up on the end. If someone wants to find out more about LeftShift, where can they go?

    John Harris:               I think it’s LeftShiftIT.com and we’ve just revamped out website, so they can find out all about our services and products and everything we offer on there.

    Alan Shimel:                Okay. And then finally John, I wanted to end with the kind of question I guess I ask just about every guest, which is for our audience out there, if they’re gonna read, what should – if they –hopefully if they do read everyone should read books. What do you recommend is the next book our audience reads?

    John Harris:               I’m a big Jez Humble fan and I’m not going to recommend Continuous Delivery, because I’m sure everyone’s read that who’s listened to the podcast, but is Lean Enterprise book – How High Performance Organizations Innovate at Scale and it’s Jez Humble, Joanne Molesky and Barry O’Reilly is an awesome book for any enterprise looking to get into this kind of area.

    Alan Shimel:                Absolutely. I actually have it on my book shelf in the office. Good one, John. Anyway, I think that’s gonna use up our time here on this edition of DevOps Chat. John Harris, LeftShift IT, thank you very much for being our guest and we look forward to hearing more about LeftShift and continuous testing service virtualization going forward and continued success.

    John Harris:               Great. Thanks for having me, Alan.

    Alan Shimel:                Thank you. This is Alan Shimel for devopsy.kinsta.cloud and DevOps Chats. Until next time, have a great day. 

  • xMatters Sees Value in Continuous Testing

    xMatters Sees Value in Continuous Testing

    xMatters builds an intelligent communications platform that alerts and connects company stakeholders for IT incident response and in manufacturing line workflow support and DevOps systems scenarios. Customers who count on xMatters also count on the effectiveness of the vendor’s continuous testing mechanisms: A failure of continuous testing early on at xMatters could lead to a magnified impact on the customers’ crises response, resulting in costly repercussions.

    XMatters uses continuous testing to promote continuous delivery of its intelligent communications platform, delivering changes to a limited number of features in an accelerated fashion. “This reduces our risks of failures and makes it easier to resolve defects,” said Deepa Guna, QA Architect at xMatters.

    For xMatters, the proper use and placement of continuous testing in the DevOps pipeline is critical to ensure the intelligent communications solution does not introduce errors during customer crises.

    xMatters Software, Languages and Tools

    The xMatters platform consists of a service stack architecture with front-end technologies accessible via the web and back-end technologies that support it. According to Guna, the platform takes advantage of Java, RESTful JSON, Node.js and Postgres, which run on data centers that are geographically dispersed in North America, Europe and the Asia Pacific regions.

    “Our data centers are built on infrastructure as a service, which includes technologies such as OpenStack, Puppet, Fabric and Consul,” Guna said. XMatters also has a mobile application for iOS and Android platforms as part of its communication service.

    xMatters Testing Approaches, Before and After DevOps

    The company’s testing before the advent of the continuous delivery pipeline included manual test execution of regression tests in the midst of a slow process of releasing one large set of features per month and deploying customer-reported defects, Guna said.

    Today, xMatters uses automated and manual regression tests and unit test code coverage monitoring, releasing small sets of features and resolved defects weekly while enabling customers to provide feedback early in the feature development process.

    XMatters uses several tests during the development, test and release phases of the DevOps pipeline and when delivering the platform to the customer. The development phase includes the following testing tools and their associated types of testing:

    • SonarQube analyzes the quality of the code.
    • Jacoco measures the code coverage of the developer unit/integrations tests.
    • Git + Jenkins run the unit and integration tests before xMatters commits the changes.

    The testing phase, Guna said, runs tests as follows:

    • Jenkins deploys artifacts in test environments and runs automated tests.
    • An automation framework that includes Jmeter, Gradle, Java, TestNG and Selenium runs its tests.

    The release phase tests software after this manner:

    • Jenkins deploys artifacts in test environments and runs automated tests.
    • An automation framework that includes Jmeter, Gradle, Java, TestNG and Selenium runs its tests.
    • Splunk and Takipi do exception monitoring.

    When xMatters delivers the platform to its customers, Guna said, it performs the following tests:

    • Runscope monitors the health of the system to ensure critical services are running.
    • Pingdom monitors the status of the customer websites.

    Drilling Down into Release Testing

    “During the release testing phase, we put the application through 1,000 fully automated and manually initiated tests that we execute with every release cycle. We also have tools that are monitoring for exception during the release testing,” Guna said. Passing this phase successfully, the new software platform release is ready to be pushed into the production environment.

    XMatters uses the continuous delivery pipeline to deploy the new platform release first to the customer staging environment and next to its production environment, Guna said. “All production environments have ongoing smoke tests that we execute every five, 10 or 15 minutes, based on customer tier, to monitor the health of the services.”

    Results Metrics

    xMatters’ method of continuous testing seems to be working for the vendor. “We have reduced the number of major incidents in production due to application defects by 40 percent this year compared to last year,” Guna noted.

  • Continuous Testing: Shift Left and Find the Right Balance

    Continuous Testing: Shift Left and Find the Right Balance

    You may have heard the term “continuous testing,” but are struggling to understand what it is and how to achieve it. Project teams need to improve their ability to test and perform test automation when needed, not just when possible. Service virtualization allows teams to test earlier and more often in the life cycle, or “shift left,“ by mimicking unavailable systems. Combining test automation with service virtualization enables teams to provide immediate feedback on quality—so issues can be resolved faster and cheaper. Encouraging and embracing this immediate feedback on the quality of the solution enables businesses to deliver high-quality innovative solutions to the market quickly.

    In addition to shifting left by using service virtualization, finding the right balance of effort across all testing practices is crucial in achieving continuous testing. The diagram below shows the key test practices that enable continuous testing, and teams spend effort on each of these practices regardless of whether they want to. The questions below may help your teams understand where they are spending time, and perhaps where their time might be better spent.

    Testing

    • Defects – Are teams spending too much time logging, triaging or analyzing defects? What about time spent on defects that aren’t “real” defects—where there is a misunderstanding between the test and the code? Or what if they could prevent entire schools of defects from ever being created in the first place?
    • Test Management – Are teams spending time manually crafting status reports and rolling up test execution results? Or do they have a tool that provides that information in real time and allows stakeholders to drill down as needed? How do teams know if they are on schedule with their test effort, behind schedule or even ahead of schedule?
    • Test Automation – How efficient are teams at re-executing existing tests? Do they run most or even all of them manually? If they’ve automated tests, are they focused only on functional tests at the user interface layer, or are they running functional API-layer tests, performance tests and even security tests? Do they have a robust and maintainable test automation framework?
    • Analytics – How do teams know which tests they should run, when and even why they are running those tests at those times? How good is their test effectiveness–meaning, are they running the fewest number of tests that find the largest number of problems? Impact analysis is critical in selecting the right sets of tests to execute whenever they get a new build.
    • Test Environments – Are teams constantly waiting on test environments to be provisioned and configured properly? Do they run tests and discover after the fact that the test environment wasn’t “right,” so they have to fix the environment and then re-run all the tests again? Do they hear from developers, “It works on my machine!” but it doesn’t work in the test environment?
    • Service Virtualization – Are teams waiting for dependent systems to become available before they can “really” test? Are they using a “big bang” approach to conduct end-to-end system testing, where they throw all the components together and hope they work and interact properly? Can teams test exception and error scenarios before going to production? Are they testing the easiest parts first just because they are available, and delaying the high-risk areas for the end of the testing effort?
    • Test Data – Do teams have the needed sets of production-like test data to ensure they are covering the right test scenarios? Are there exception and error scenarios that we can’t execute because they don’t have the right sets of test data?

    If any of these problems or ideas resonate with you, here is guidance on how to get started on the journey to achieve continuous testing.

    First, identify your bottlenecks:

    • How good is your test efficiency – are you able to run the needed tests and provide feedback quickly?
    • How good is your test effectiveness – are you running the fewest number of tests that find the largest number of problems?
    • Bottlenecks may also be upstream or downstream from actual test execution effort – are you waiting on dependent systems, or test environment provisioning?

    Then, look at all aspects of your test effort and focus on the largest bottlenecks first.

    • How long are your delays in test environment provisioning, and are the environments accurate when they are provisioned? If delays are too long and environments aren’t correct, automate your test environment provisioning and configuration to eliminate manual errors and gain accuracy and reliability.
    • Are you waiting on dependent systems to start testing? If so, use service virtualization to simulate those unavailable systems so you can start testing sooner.
    • Are you unable to run all the needed tests before the next build is available? If this is the case, automate your high-risk regression tests to improve test efficiency.
    • Do you find performance problems late in the life cycle, or even in production? Outages can result in long-term damage to a business, so conduct load, performance and stress testing earlier in the life cycle.
    • Do you find significant problems when all systems are integrated? Identify and agree upon system interface and data definitions, and create automated integration level tests for the high-risk integration points.

    Teams that improve their test efficiency and effectiveness significantly reduce their expenses and the time it takes to get high-quality, innovative solutions to users. You can’t test everything, and you can’t automate all your tests, so it is critical to find the right balance. Also key is service virtualization, which allows testing to begin as soon as a build is made by mimicking missing dependencies. By combining test automation and service virtualization, teams can test earlier, or “shift left,” so they gather feedback faster than ever.

    Learn more about using service virtualization to shift left and avoid downtime in test environments in our upcoming webcast:  How Maersk Uses Service Virtualization to Shift Left and Avoid Test Downtime.

    About the Author / Marianne Hollier

    MarianneMarianne Hollier is an IBM and Open Group Master Certified IT Specialist in application development. She has strong, practical expertise in measurably improving the software development life cycle and driving the necessary cultural changes to make it work. She is instrumental in architecting, tailoring and deploying the IBM DevOps best practices as well as appropriate software development tools on many types of projects, from large to small, long to fast-track, agile to traditional. Marianne is especially passionate about all things testing—process, tools, culture and automation. Her experience is broad-based, spanning both custom projects as well as standard software packages that apply to many industries, including refining, pharmaceutical, telecommunications, health care, financial, automotive, government and retail. Connect with Marianne on LinkedIn or Twitter.

  • LogiGear Launches Continuous Testing Solution and Service to Enable Faster High Quality Testing 

    New solution is an addition to the company’s evolving frameworks and technologies

    Foster City, CA, July 12, 2016— LogiGear, a world leader in software testing solutions, today announced the launch of its Continuous Testing (CT) solution and service to enable improvements in automated testing in DevOps environments. LogiGear’s Continuous Testing solution and its full-range of testing automation services will help customers with the transformation from manual to continuous testing methods.

    Continuous Testing is a process of executing automated tests at every stage of the software delivery pipeline. CT allows for fixing errors quickly, enhancing the speed of delivery, thereby reducing time to market, allowing firms to save time and resources. CT is an integral part of Continuous Delivery and DevOps practices and LogiGear’s experts help companies achieve maximum ROI by supporting the transformation to Continuous Delivery (CD) and DevOps initiatives.

    “DevOps and Continuous Delivery are gaining traction because of its potential to deliver high quality results faster. Continuous Testing is essential to achieving success. However, many companies face challenges in completing the transformation,” said Hung Nguyen, CEO of LogiGear. “With the Continuous Testing solution and services, LogiGear will ease the pain of transformation for them.”

    LogiGear’s CT solution and service helps solve common challenges associated with Continuous Testing, including creating a unified platform for quality reporting and collaboration as well as enabling companies to achieve Continuous Testing with Legacy systems. LogiGear’s solution also removes high start-up costs, a popular challenge associated for most firms looking to adopt DevOps.

    For additional information on Continuous Testing Solution, or on the full range of software testing and development services provided, visit LogiGear.com.

    About LogiGear

    LogiGear Corporation (http://www.logigear.com) provides leading-edge software testing technologies and expertise, along with software development services that enable companies to accelerate business growth while having confidence in the software they deliver. Founded in 1994 by top thought leaders in the software testing industry, LogiGear has completed software testing and development projects for prominent companies across a broad range of industries and technologies.

    #

    For more information or interview requests:

    Joanne Hogue

    Smart Connections PR

    (410) 658-8246

    joanne@smartconnectionspr.com

  • Continuous Testing Live Network DevOps

    Continuous Testing Live Network DevOps

    My earlier blog, “From Laboratories to DevOps: Factories for Continuous Testing,” discussed the importance of and suggested practices for a fully automated, orchestrated software DevOps laboratory infrastructure, akin to a modern factory staffed by robots churning out products at a dizzy pace. The blog applies to development of software for networks, and the practices increasingly are important as the network becomes more software-based thanks to software-defined networking (SDN),  network functions virtualization infrastructure (NFVI) and cloud-based networking. The edges of mobile networks, even the radio access networks, are becoming more software-dependent due to the need to position computing resources closer to mobile customers to resolve latency, bandwidth and spectrum concerns.

    However, the need for highly automated software processes does not stop within the development lab.

    At a recent DevOps Networking event in Santa Clara, California, Google Network Operations Manager Anees Shaikh indicated that Google’s live network has many thousands of nodes and management elements, supported by millions of lines of software-based configuration files that are updated tens of thousands of times per month. The sheer volume and speed of software updates for large networks is not feasible using manual methods. Automation tools for live network software updates are vital.

    Typical live network DevOps environments use DevOps continuous tool chains such as Git for software version management, YAML for defining abstract configuration definitions, Jinja2 to translate the configurations into concrete templates that can be consumed by real devices and Ansible for automating the distribution and activation of config files to the network nodes. But what about testing? How can a network operator be confident that the many updates will perform as expected once deployed across the live network? This requires much more than simple syntax and semantics checking of the config file entries.

    Recommended Practices for Continuous Testing of Live Network DevOps Environments

    For continuous testing of live network DevOps environments to work, here are some best practices to consider:

    1. Lab-to-live transition: Prior to deployment of any updates to the live network software updates should be tested in a lab environment using production-equivalent equipment and topologies.
    2. What to test? The actual tests to be executed depend on the risk of changes that are being deployed. If a small, low-risk configuration change is all that is being deployed, then a simple configuration check may be sufficient. On the other hand, if a change has the potential to disrupt the network performance significantly, then a much more comprehensive performance test is needed.
    3. Test orchestration tools: The test environment prior to deployment will vary depending on the tests that are selected. Test environment orchestration tools are needed to set up network test topologies that match the tests rapidly—and release them just as rapidly so the test resources can be used for the next tests.
    4. Elastic on-demand topologies: The ability to scale test resources horizontally and vertically, on-demand, is essential to be able to match the speed of testing required for short duration deployment cycles.
    5. Automate live network tests during deployment: To verify software updates do not interrupt or degrade network performance, functional and performance tests between pairs of nodes across the network mesh are required as the updates are deployed in stages across the live network nodes, clusters, centers and regions.
    6. Automate live network testing after deployment: After verifying that the deployments are successful, network tests need to be scheduled periodically to ensure latent problems with the new software do not impact the network.

    This is just a partial list of suggestions for continuous testing essentials for live network DevOps.

  • Continuous Testing Improves Speed, Quality

    Continuous Testing Improves Speed, Quality

    We live in a world that expects immediacy. For a society that gets news updates from Twitter in 140-character increments as it happens while we microwave a complete meal in less than five minutes, anything that takes months—or even weeks or days—seems like an eternity.

    When it comes to continuous performance testing, organizations and developers need to keep up with the accelerated pace of development common in a DevOps environment—but without sacrificing the quality of the testing. That’s the real challenge.

    Twitter can deliver news virtually in real time, but the quality of the “journalism” is sometimes questionable. It’s possible to microwave a meal in a matter of minutes, but few would argue that the resulting food is actually as good as the same dish prepared the old-fashioned way. When it comes to continuous performance testing, you can’t afford to sacrifice the quality of the testing in the name of expediency.

    BlazeMeter thinks it has a way to address that challenge. It recently announced new functionality that allows developers to run tests using Gatling, The Grinder, Locust, Selenium, and JMeter—both locally and in the cloud—in parallel using a single, unified control language.

    BlazeMeter referenced statements from Diego Lo Giudice, vice president & principal analyst for Forrester, who noted during a recent webinar the demand for software development speed is pushing teams to look at delivery cycles in terms of weeks, days, hours and even seconds.

    The ability to run the tests in parallel shortens the build/test cycles. Developers can add more tests without extending the time involved in the testing cycle. Because all of the tests are run simultaneously, the total time will be only as long as the longest single test in the bunch, no matter how many tests are included in the mix. Running the tests simultaneously allows organizations to achieve greater speed without sacrificing the quality of the testing results.

    “Developers that want to excel in the era of continuous delivery need tools that give them the most speed and flexibility possible,” said Andrey Pokhilko, chief scientist at BlazeMeter, in a press release. “We’ve been working with the open source community to develop ideal performance testing tools for any scenario. The new functionality combines the best of our community work with the infrastructure we’ve built up at BlazeMeter, marking a new set of capabilities to bring performance testing to new heights.”

    The new BlazeMeter capability also streamlines testing by giving developers a unified control language for managing it all. BlazeMeter developed a “performance-tests-as-code” format that lets developers define tests using common YAML or JSON file formats. Testing teams can create load and performance tests as small fragments using any text editor. The BlazeMeter format enables developers to manage test logic and performance thresholds for various open source tools without needing to be an expert in the separate tools themselves.

    A unified solution that allows for simultaneously running multiple test loads in parallel seems like a valuable tool for continuous performance testing. If it works as advertised, it seems BlazeMeter has combined simplicity, speed and quality in one.

  • Evolving to Continuous Testing

    Evolving to Continuous Testing

    As agile development practices mature and DevOps principles infiltrate our corporate cultures, organizations are realizing the distinct opportunity to accelerate software delivery. However, when you speed up any process, immature practice areas such as testing and roadblocks become much more pronounced. It’s the difference between driving over a speed bump at 5 mph vs. 50 mph … at 50 mph, that speed bump is going to be quite jarring.

    Accelerating any business process will expose systemic constraints that shackle the entire organization to its slowest moving component. In the case of the accelerated software development life cycle (SDLC), testing has become the most significant barrier to taking full advantage of more iterative approaches to software development. For organizations to leverage these transformative development strategies, they must shift from test automation to continuous testing.

    Drawing a distinction between test automation and continuous testing may seem like an exercise in semantics, but the gap between automating functional tests and executing a continuous testing process is substantial. This gap will be bridged over time as the process of delivering software matures. Both internal and external influences will drive the evolution of continuous testing. Internally, agile, DevOps and lean process initiatives will be the main drivers that generate the demand for change. Externally, the expense and overhead of auditing government and industry-based compliance programs will be the primary impetus for change.

    A Roadmap for Testing

    Any true change initiative requires the alignment of people, process and technology—with technology being an enabler and not the silver bullet. Yet there are some basic technology themes we must explore as we migrate to a true quality assurance process. In general, we must shift from a sole focus on test automation to automating the process of measuring risk. To begin this journey, we must consider the following:

    Driven by business objectives, organizations must shift to more automated methods of quality assurance and away from the tactical task of testing software from the bottom up.
    graphic

    From Causal Observations to Probabilistic Risk Assessment

    With quality assurance (QA) traditionally executing manual or automated tests, the feedback from the testing effort is focused on the event of a test passing or failing—this is not enough. Tests are causal, meaning that tests are constructed to validate a very specific scope of functionality and are evaluated as isolated data points. Although these standalone data points are critical, we must also use them as inputs to an expanded equation for statistically identifying application hot spots.

    The SDLC produces a significant amount of data that is rather simple to correlate. Monitoring process patterns can produce very actionable results. For example, a code review should be triggered if an application component experiences all of the following issues in a given continuous integration build:

    • Regression failures greater than the average
    • Static analysis defect density greater than the average
    • Cyclomatic complexity greater than a prescribed threshold

    From Defect Documentation to Simulated Replay

    The ping-pong between testers and developers over the reproducibility of a reported defect has become legendary. It’s harder to return a defect to development than it is to send back an entrée from a world-renowned chef. Given the aggressive goal to accelerate software release cycles, most organizations will save a significant amount of time by just eliminating this back and forth.

    By leveraging Service Virtualization for simulating a test environment and/or virtual machine record and playback technologies for observing how a program executed, testers should be able to ship development a very specific test and environment instance in a simple containerized package. This package should isolate a defect by encapsulating it with a test, as well as give developers the framework required to verify the fix.

    From Structured Data to Structured and Unstructured

    The current tools and infrastructure systems used to manage the SDLC have made significant improvements in the generation and integration of structured data (e.g., how CI engines import and present test results). This data is valuable and must be leveraged much more effectively (as we stated above in the “From Causal Observations to Probabilistic” section.

    The wealth of unstructured quality data scattered across both internal and publicly-accessible applications often holds the secrets that make the difference between happy end users and unhappy prospects using a competitor’s product. For example, developers of a mobile application would want constant feedback on trends from end user comments on:

    • iTunes app store
    • Android app store
    • Stackoverflow
    • Twitter
    • Facebook
    • The company’s release announcements
    • Competitors’ release announcements

    This data is considered unstructured since the critical findings are not presented in a canonical format: parsing and secondary analysis are required to extract the valuable information. Although these inputs might be monitored by product marketers or managers, providing these data points directly to development and testing teams—in terms that practitioners can take action on—is imperative.

    From Dashboards to Business Policies

    In a Continuous Everything world, quality gates will enable a release candidate to be promoted through the delivery pipeline. Anything that requires human validation clogs the pipeline. Dashboards require human interpretation—delaying the process.

    Dashboards are very convenient for aggregating data, providing historical perspectives on repetitive data, and visualizing information. However, they are too cumbersome for real-time decision making because they do not offer actionable intelligence.

    Business policies help organizations evolve from dashboards to automated decision making. By defining and automatically monitoring policies that determine whether the release candidate is satisfying business expectations, quality gates will stop high-risk candidates from reaching the end user. This is key for mitigating the risks inherent in rapid and fully-automated delivery processes such as Continuous Delivery.

    From Tool Dependent to SDLC Sensors

    Let’s face it—it’s cheap to run tools. And with the availability of process intelligence engines, the more data observations we can collect across the SDLC, the more opportunities will emerge to discover defect prevention patterns.

    Given the benefit of a large and diverse tool set, we need to shift focus from depending on a single “suite” of tools from a specific vendor (with a specific set of strengths and weaknesses) to having a broad array of SDLC sensors scattered across the software development life cycle. And to optimize both the accuracy and value of these sensors, it’s critical to stop allowing tools to be applied in the ad hoc manner that is still extremely common today. Rather, we need to ensure they are applied consistently and that their observations are funneled into a process intelligence engine, where they can be correlated with other observations across tools, across test runs and over time. This will not only increase the likelihood of identifying application hot spots, but will also decrease the risk of false negatives.

    About the Author/Wayne Ariola

    Wayne Ariola (1)Wayne Ariola, Chief Strategy Officer, leads the development and execution of Parasoft’s long-term strategy. He leverages customer input and fosters partnerships with industry leaders to ensure that Parasoft solutions continuously evolve to support the ever-changing complexities of real-world business processes and systems. Ariola has contributed to the design of core Parasoft technologies and has been awarded several patents for his inventions. A recognized leader on topics such as service virtualization, SOA and API quality, quality policy governance, and application security, Ariola is a frequent contributor to publications including software test & performance, SOA World, and ebizQ—as well as a sought-after speaker at key industry events. Ariola brings more than 20 years strategic consulting experience within the technology and software development industries.