Email Subscription Form

Saturday, May 30, 2020

Book Review: Perfect Software and Other Illusions About Testing

"Perfect Software and Other Illusions About Testing", by Gerald Weinberg, is the best book on testing I have ever read.  It is a must-read for anyone who works with software: CEOs, CTOs, scrum masters, team leads, developers, product owners, business analysts, and software testers.

Before I get into why this book is so great, I'll first acquaint you with the author.  Gerald "Jerry" Weinberg (1933-2018) was involved in the creation of software for over fifty years.  Early in his career he worked for NASA on Project Mercury, the project that created spacecraft that allowed a human to orbit the earth.  For decades he consulted with companies about building quality software, and over those years he gained a great deal of wisdom about software testing.  "Perfect Software", which was published in 2014, seems to me to be the culmination of his years of experience.


The book is divided into several chapters, each of which looks at a particular aspect of software testing. Many examples are given from Jerry's consulting experience, and each chapter closes with a summary and a list of common mistakes that companies make.  Rather than summarizing the lessons he imparts, I think it would be best to include Jerry's own words here.  Here are some of my favorite quotes from the book:

"Before you even begin to test, ask yourself: What questions do I have about this product's risks?  Will testing help answer these questions?"

"There are an infinite number of possible tests...Since we can't test everything, any set of real tests is some kind of sample- a portion, piece, or segment that is in some way representative of a whole set of possible tests."

"Knowing about the structure of the software you're testing can help you to identify special cases, subtle features, and important ranges to try- all of which can help narrow the inference gap between what the software can do and what it will do during actual use."

"Testing gathers information about a product; it does not fix things it finds that are wrong."

"If you're going to ignore information or go ahead with predetermined plans despite what the tests turn up, don't bother testing."

"If you blame messengers for bringing news you don't want to hear, you'll be rewarded by not hearing the news you should hear."

"Quality is a product of the entire development process.  Poor testing can lead to poor quality, but good testing won't lead to good quality unless all other parts of the process are in place and performed properly."

"Testing starts at project conception, or before. If you don't know this, you don't understand testing at all."

"Without a process that includes regular technical reviews, no project will rise above mediocrity, no matter how good its machine-testing process."

"No developer is good enough to consistently do it alone, and do it right."

"Data are meaningless until someone determines their meaning.  Different people give different meanings to the same data.  Gather data, then sit down and ponder at least three possible meanings."

"When someone says, 'The response should be very fast', what does that mean, exactly?  What meanings do 'should', 'very', and 'fast' give to the stated information?"

"Numbers can be useful, but only if they're validated by personal observation and set in context by a story about them."

"Garbage arranged in a spreadsheet is still garbage."

Jerry uses many great hypothetical scenarios to illustrate his points, and he also uses real-world examples from his years of consulting.  Here are some of my favorites:

  • The tester who didn't log a bug he found because it wasn't in "his" component
  • The manager who thought that the project was ready to ship because they ran 600,000 test cases and "nothing crashed the system"
  • The team who thought their biggest problem was their bug-tracking system, because the system couldn't handle their 140,000 open bugs
  • The team who took so long to triage bugs that couldn't make a decision on any of them, resulting in 129 undiscussed and unfixed bugs
  • The tester who assumed that her new automated test tool was working correctly because all the tests displayed in green at the end
  • The developer-tester team who were gaming the bug bounty system by having the developer add bugs to the code, the tester find the bugs quickly, and the developer fix them just as quickly, resulting in rewards for both
  • The VP of Development who wanted a really big written test plan so he could have something big to slam down on a desk to "prove" that they had tested well

If you would like to think about what role testing plays in your software development project, what constitutes a good test, how to plan testing for a project, or how to interpret test data in order to make management decisions, then "Perfect Software" is the book for you.  I plan to re-read this book every year to make sure that I have fully retained all the lessons it offers.

Saturday, May 23, 2020

Rarely Used HTTP Methods

A couple of months ago, one of the developers I work with asked me to test a bug fix he'd done.  In order to test it, I'd need to make an HTTP request with the OPTIONS method.  I'd never heard of the OPTIONS method, and it got me thinking: what other HTTP methods did I not know about?  In this post, I'll talk about four rarely used methods and and how you might use them in your testing.

OPTIONS:
This method returns whatever methods are allowed for a particular endpoint.  For example, if you had a URL called http://cats.com/cat, and you could use it to get a list of cats or add a cat, the methods that the OPTIONS request would return would be GET and POST.

OPTIONS demo:
Let's use the Restful-Booker API to try out the OPTIONS method.  Assuming you have Postman installed, we'll create a new GET request that calls this URL: https://restful-booker.herokuapp.com/booking. When you run this request, you'll see a list of all the available hotel-bookings for the app in the response body. Now let's change the method from GET to OPTIONS. When you run this request, you'll see GET, HEAD, and POST in the response body. These are the three methods that are available for this endpoint.

Why would you use the OPTIONS method?
If you are testing an API, this is a great way to find out if there are any valid endpoints that you don't know about. This can reveal more features for you to test, or it could potentially reveal a security hole. For example, maybe your API shouldn't really have a DELETE method, but someone implemented it by mistake.

HEAD:
This method returns only the headers of the response to a GET request. It's used if you want to check the response headers without putting pressure on the server to return other data.

HEAD demo:
We'll use the very same URL that we used for our OPTIONS demo. First, let's return our method to GET. Run the request, and see that you get a response body with the list of available bookings. Take a look at the headers that were returned with the response: Server, Connection, X-Powered-By, Content-Type, Content-Length, Etag, Date, and Via. Now let's change our verb to HEAD and re-run the request. We won't get anything in the body of the response, but we will get those same eight headers.

Why would you use the HEAD method?
This method would be a great way to check the headers of a GET response without having to actually return data. Headers are important because they often help to enforce security rules. If you know what headers your API should be returning, you can run this request on all of your endpoints to make sure that the right headers are being used.

CONNECT:
This method establishes a tunnel to the server that is identified by a URL. It's often used for proxy connections.

CONNECT demo:
For this demo, you'll need to have curl enabled. You can check to see if curl is installed on your machine by typing curl --version in your command line window. If you get a version back, you have curl installed.

To try out CONNECT, type this command into your command line window: curl -v CONNECT http:///kristinjackvony.com. Take a look at the response you get; about nine lines from the bottom, you'll see the message "301 Moved Permanently". This is because I recently changed this domain name to point to my Thinking Tester webpage instead of my personal webpage. I didn't do that because of this tutorial, but it wound up being useful!

Why would you use CONNECT?
You'd use CONNECT any time you want to see exactly what happens when you try connecting to an HTTP resource. This could be helpful with security testing, and any time you are using a proxy.

TRACE:
This method is similar to CONNECT in that it connects to a resource, but it also tries to get a response back.

TRACE demo:
We'll use curl again to try out TRACE. Type this command in the command window: curl -v TRACE http://isithalloween.com. You'll get back some response headers, plus the source code for the page.

Why would you use TRACE?
This would be good for security testing. Because you get the source code for the page in the response, you can inspect it to see if there are any cookies or authentication headers that a malicious user could exploit.

I hope you've gotten some good testing ideas from these rarely used HTTP methods! In my research I found all kinds of other methods that appear to no longer be in use, such as COPY, LINK, UNLINK, LOCK, and UNLOCK. Have you ever used these, or other rare methods? Tell me about it in the comments!

Saturday, May 16, 2020

Seven Steps to Solve Any Coding Problem

I am not the world's greatest coder, although I am getting better every year.  One thing that I'm really improving on is my ability to solve coding problems.  I'm not talking about those coding challenges that you can get online or in a job interview; I'm talking about those real-world problems, like "How are we going to create an automated test for this?"  Here are the seven steps I use to solve any coding problem. 


Step One:  Remember what problem you are trying to solve

When you're trying to figure out how to do something, it can be easy to forget what your original intent was.  For example, let's say you are trying to access a specific element on a web page, and you're having a really tough time doing so; perhaps the element is in a popup that you can't reach, or it's blocked by something else.  It's easy to get so bogged down in trying to solve this problem that you lose sight of what your original intent was- to add a new user to the system.  When you remember this, you realize that you could actually add a new user to the system by calling the database directly, avoiding the whole issue that you were stuck on!

Step Two: Set Small Steps

I often have what I want to do in my code all figured out long before I know how I'm going to it.  And I used to just write a whole bunch of code even if I wasn't sure it was all going to work correctly.  Then when I tried to run the code, it didn't work; but I wrote so much code that I didn't know whether I had one problem or many.  This is why I now set small steps when I code.  For example, when I was trying to write the email test that I mentioned in last week's post, I first set myself the goal of just reaching the Gmail API.  I didn't care what kind of token I used, or what information I got back; I just wanted a response.  Once I had solved that, then I worked on trying to get the specific response that I wanted.  This strategy also keeps me from getting frustrated or overwhelmed.

Step Three: Change One Thing at a Time

This step is similar to Step Two, but it's good for those times when your code isn't working.  It's very tempting to thrash around and try a number of different solutions, sometimes all at once, but that's not very helpful.  Even if you get your code to work by this method, you won't know which change it was that caused the code to work, therefore you don't know which changes were superfluous.  It's much better to make one small change, see if it works, remove that change and try a different change, and so on.  Not only will you solve your problem faster this way, but you'll be learning as you go, and what you learn will be very valuable for the next time you have a problem.

Step Four: Save All Your Work

I learned this one the hard way when I was first writing UI automation.  I had absolutely no idea what I was doing, and sometimes I'd try something that didn't completely work and then delete it and try something else.  Then I'd realize that I needed some of the lines of code from the first thing I tried, but I had deleted them, so I had to start from scratch to find them again.  Now when I'm solving a new coding challenge I create a document that I call my scratch pad, and when I remove anything from my code I copy it and paste it in the scratch pad, just in case I'll need it again.  This has helped me solve challenges much more efficiently.

Step Five: See What Others Have Done

People who are good at solving coding problems are usually also masters of Google Fu: the art of knowing the right Google search to use to get them the answers they need.  When I first started writing test automation, I was not very good at Google Fu, because I often wasn't sure of what to call the thing I wanted to do.  As I've grown in experience, I've become better at knowing the terminology of whatever language I'm using, so if I've forgotten something like whether I should be using a static method I can structure my search so I can quickly find the right answer.  The answers you find on the Internet are not always the right ones, and sometimes they aren't even good ones, but they often provide clues that can help you solve your problem.

Step Six: Level Up Your Skills

As I mentioned in this post, I've been taking a really great Node.js course over the last three months.  I'm not even halfway done with it yet, and I've already learned so much about Node that I didn't understand before.  Now that I understand more, writing code in Node.js is so much easier.  Rather than just copying and pasting examples from someone on Stack Overflow, I can make good decisions about how to set things up, and when I understand what's going on, I can write code so much faster.  Take some time to really learn a coding language; it's an investment that will be worth it!

Step Seven: Ask For Help

If you've finished all your other steps and still haven't solved your problem, it's time to ask for help.  This should definitely not be Step One in your process.  Running for help every time something gets hard will not make you a better coder.  Imagine for a while that there's no one who can help you, and see how far you can get on your own.  See what kind of lessons you can learn from the process.  Then if you do need to ask for help, you'll be able to accurately describe the problem in such a way that your helper will probably be able to give you some answers very quickly.  You'll save them time, which they will appreciate.

Coding is not magic: while there are all sorts of complex and weird things out there in the world of software, an answer exists for every question.  By using these seven steps, you'll take some of the mystery out of coding and become a better thinker in the process!

Saturday, May 9, 2020

Testing Email Without Tears

Several years ago, when I was first learning test automation, I needed to create a test for my company's email service.  I had configured the service to deliver an email every day, and I wanted an automated test that would check my test Gmail account and determine if the email had been delivered.  At the time, the only automated testing I knew about was Selenium Webdriver with Java.  So I wrote an automated test that would open a browser, navigate to the Gmail client, log in, and search the page for the email.

This test didn't work out very well.  First of all, there could be a delay of up to ten minutes before the email was delivered, so it wound up being a long-running test.  Secondly, any time Google made changes to the email page, I had to update my element locators.  And finally, I didn't have a good way to identify the email, so sometimes the test would think that yesterday's email was today's and mistakenly pass the test.

So when I recently found myself with the need to test an email delivery again, I knew there had to be a better way!  This time I created an automated test using the Gmail API, and I'll share here how I did it.


The first step is obviously to obtain a Gmail account to test with.  You will not want this to be your personal Gmail account!  I already had a test account that is shared with a number of other testers at my company.

The trickiest part of using the Gmail API is coming up with an access token to use for the API requests.  Using this post by Martin Fowler, this blog post, this Quickstart documentation from Google, and some trial and error, I was able to obtain a refresh token that could be used to request the access token.  The Gmail API Quickstart application is easy to create, and can be done in a number of different languages, such as .NET, Java, NodeJS, Python, and Ruby.  You just choose which language you want to use and follow the simple steps.

Once the Quickstart application has been created, you run it.  When the application runs, it will prompt you to authenticate your Gmail account and give permission for the Gmail API to access the account.  After this is completed, you'll have a token.json file that contains a refresh token and a credentials.json file that contains a client id, a client secret, and a redirect URI.

I ran the Quickstart application in .NET, but I didn't actually want my test to be in .NET.  I wanted to write my test in Powershell.  For those unfamiliar with Powershell, it's a Windows command line language that offers more advanced commands than the traditional command line.  I took the refresh token, client id, client secret, and redirect URI from the Quickstart application files and created this request body:

$RefreshTokenParams = @{
client_id=$clientId;
client_secret=$secret;
refresh_token=$refreshToken;
grant_type='refresh_token';
}

Then I used this request to create a refreshed token:

$RefreshedToken = Invoke-WebRequest -Uri "https://accounts.google.com/o/oauth2/token" `
-Method POST -Body $RefreshTokenParams | ConvertFrom-Json

The refreshed token contained the access token I needed, so I grabbed it like this:

$AccessToken = $RefreshedToken.access_token

Now I had the token I needed to make requests from the Gmail API. Note that the refresh token I got from the Gmail Quickstart application won't last forever; in the event that it gets revoked at some point in the future, I can simply run the Quickstart application again and I'll have a new token to use in my script.

Next, I added a command in my script to send an email. I can do this with a simple POST request using my team's email function; how you create an email for testing will of course vary.

Then I created the request to the Gmail API:

$header = @{
    Authorization = "Bearer $AccessToken"
}

$emailList = Invoke-RestMethod `
-Uri 'https://www.googleapis.com/gmail/v1/users/<emailaddresshere>/messages' `
-Method 'GET' -Header $header

The <emailaddresshere> was of course replaced by my test email address.

This request got me a list of the twenty-five most recent emails to my test account. I grabbed just the first ten of them, then I looped through those ten to find the email that matched the one I sent.

You may be wondering at this point how I was able to tell my latest email apart from all the other emails. I did this by creating a random GUID and including that GUID at the very beginning of the email message. The Gmail client saves the first several characters of an email message as a "snippet", and as I looped through the ten emails I saved, I looked for the GUID in each snippet. When I found a match, I was able to programmatically examine that email to see if it had the attachment I was expecting.

Of course, emails are not delivered instantaneously, even when we're checking the API rather than logging into the client on the browser. So I built in some waits and retries to make sure that my test didn't fail simply because the email hadn't been delivered yet. So far, waiting thirty seconds has been enough to ensure that the email has been delivered, meaning my test takes well under a minute; much faster than that UI test I created years ago!

The moral of this story is not just that testing email is easier and more reliable with an API test than a UI test; it's also that APIs are great to test all kinds of things! The next time you find yourself needing to access a third-party application for an automated test, see if that app has an API. Your test will be less flaky, so you won't have to waste lots of time rerunning and debugging it!

Saturday, May 2, 2020

Six Testing Personas to Avoid

If you are working for a company that makes software for end users, you have probably heard of user personas.  A user persona is a representation of one segment of your application's end users.  For example, if you worked for a company that made a website for home improvement supplies, one of your user personas might be New Homeowner Nick, who has just purchased his first home and might not have much experience fixing small things in his house.  Another persona might be Do-It-Yourself Dora, who has lots of experience fixing everything in her home herself.

It occurred to me recently that there are also testing personas.  But unlike our user personas, these personas are ones we want to avoid!  Read on to see if one of these personas applies to you.


1. Test Script Ted
Ted loves running manual test scripts and checking them off when they're completed.  It gives him a feeling of satisfaction to see tests pass.  He doesn't particularly care if he doesn't understand how his application works; he's just satisfied to do what he's told.  But because he doesn't understand how the application works, he sometimes misses important bugs.  If he sees something strange, but it's not addressed in the test plan, he just lets it slide.  His job is to test, not figure things out!

2. Automation Annie
Annie considers herself an automation engineer.  She considers manual testing a colossal waste of her time.  She'd rather get into the hard stuff: creating and maintaining automated tests!  When a new feature is created, she doesn't bother to do any exploratory testing; she'll just start coding and she figures her great automation will uncover any issues.

What Ted and Annie have in common:
Ted and Annie are making the same mistake for different reasons; they are not taking the time to really learn how their application works.  They're both missing bugs because of a lack of understanding; Ted doesn't understand the code that makes the features work, and Annie doesn't understand the use cases of the application.

How not to be Ted or Annie:
To be a thorough tester, it's important to take the time to understand how your features work.  Try them out manually; explore their limits.  Look in the code to see if there are other ways you might test them.  Ask questions when you see things that don't make sense.

3. Process Patty
Patty is passionate about quality.  She likes things to work correctly.  But she likes having processes and standards even more!  She's got test plans and matrices she's expecting her team to follow to the letter.  Regression testing must be completed before any exploratory testing is done, and there are hundreds of regression tests to be run.  The trouble is, with releases happening every two weeks there's no time to do any exploratory testing.  There's no time to stop and think about new ways to test the product, or what might be missing.  The team needs to get all those regression tests completed!

4. Rabbit Hole Ray
Ray is passionate about quality too; he doesn't want any bug to go unnoticed.  So when he sees something strange in the application when it runs on IE10, he's determined to find out what's wrong!  He will take days to investigate, looking at logs and trying different configuration scenarios to reproduce it. He doesn't want to be bothered with the standard regression tests that he's leaving undone as the feature is being released. And he doesn't care that only 1% of their customers are using IE10.  He's going to solve the mystery!

What Patty and Ray have in common:
Patty and Ray are both wasting time.  They are focused on something other than the primary objective: releasing good software on time with a minimum of defects.  Patty is so caught up in the process that she doesn't see the importance of exploratory testing, which could find new bugs.  And Ray is so obsessed with that elusive bug he's exploring that he's ignoring important testing that would impact many more users.

How not to be Patty or Ray:
When testing a new feature or regression testing existing ones, it's important to think about which tests will have the biggest impact and plan your testing accordingly.  Be careful not to get too caught up in processes, and if that elusive bug you're searching for won't be that impactful to end users, let it go.

5. Job Security Jim:
Jim's been working at his current position for years.  He knows the application like the back of his hand.  He's the go-to guy for all those questions about how the most ancient features behave.  He knows there's no way the company will let him go; he knows too much!  So he doesn't feel like there's any reason to learn new skills.  What he knows has served him just fine so far.  Who needs to waste time after work learning the latest programming language or the newest testing tool?

6. Conference Connie:
Connie is so excited about tech!  She loves to hear about the latest testing techniques and the latest development trends.  She signs up for webinars, goes to conferences, reads blog posts, and takes courses online.  She knows a little about just about everything!  But she's never actually implemented any of the new things she learns.  She's so busy going to conferences and webinars that she barely has time to do her regular testing tasks.  And besides, trying things out is a lot of work.  It's easier to just see how other people have done it.

What Jim and Connie have in common:
Jim and Connie seem like total opposites at first: Jim doesn't want to learn anything new, and Connie wants to learn everything new.  But they actually have the same problem: they are not growing as testers.  Jim is content to do everything he's already learned, and doesn't see any reason to learn anything more.  But he could be in for a shock one day if his company decides to rewrite the software and he suddenly needs a new skill.  And Connie has lots of great ideas, but great ideas don't mean anything unless you actually try them out.  Her company isn't benefiting from her knowledge because she's not putting it to use.

How not to be Jim or Connie:
It's important to keep your testing skills fresh by learning new languages, tools, and techniques.  You don't have to learn everything under the sun; just pick the things that you think would be most beneficial to your current company, learn them, and then try to implement them in one or two areas.  Your teammates will be thankful for the new solutions you introduce, and you'll be developing marketable skills for your next position.

Be a great tester, not a persona!
We all become some of these personas now and then.  But if we can be aware of them, we can catch ourselves if we start to slip into Automation Annie or Rabbit Hole Ray, or any of the others.  Great testers learn their application better than anyone else, they make good choices about what to test and when, and they keep their skills updated so their testing keeps getting better.

New Blog Location!

I've moved!  I've really enjoyed using Blogger for my blog, but it didn't integrate with my website in the way I wanted.  So I&#...