Skip to main content

The 5s Methodology to Testing

This morning I finally got round to start reading a new book, a book I've been saying that I'll read for a while, actually this could apply to 2 books, as I've also started reading a non work related book in Game Of Thrones, which I thought might fill up some time between the series starting up again... Game Of Thrones is amazing, you should most definitely read it... however I digress, the book that prompted this blog post is Clean Code: A Handbook of Agile Software Craftsmanship (Robert C. Martin)

Obviously having only started reading it this morning, there's a specific excerpt that caught my attention and one that has made me want to write a blog post... and apologies it's been a while... However, the book talks about the 5S Methodology they apply it to coding principles, and whilst that's still useful for this blog, I wanted to try and apply it to testing principles, so here goes...

For those not familiar with the 5S Methodologies, they are 5 Japanese words, and I've listed them here (copied from Wikipedia): seiri, seiton, seiso, seiketsu and shitsuke.

Now the fun part, applying these to some solid testing principles:

  • Seiri (Sort)

How can this be a testing principle you may ask? Well, it can be used to explain how test cases should be visible. They should have relevant naming, the test/check should clearly state what it is testing/checking, both automated checks and manual tests. All too often I have seen test case names as 1 words with no real description of what the test is doing how it's to be run etc. In some cases this may be okay (I can't really think of one though), but not when we are talking about acceptance tests that other people may be required to run. (Clean Code does talk about naming conventions for variables etc. I'll probably write more about this at a later date)...

  • Seiton (Systemic Arrangement)

They should be where one expects to find them. This applies to both automated checks and manual tests, if it is an automated test, then ideally they should live with the solution/code they are testing, if they are manual tests, then they should be organised in such a way that "makes sense", they should be easy to find and structured accordingly. It's about making other testers lives easier if they wish to view test cases, it should be instinctive where to find the tests for a certain piece of software.

  • Seiso (Shine)

The test cases and checks should be kept up to date, whether automated checks or manual tests, they need to be run regularly and fix any failing tests, remove out of date tests, apply the boy scout principle,  "Always leave the campground cleaner than you found it" by applying this to our tests, we're talking about refactoring broken/failing tests, we can only do this if they are run regularly. If they're not run regularly we're not refactoring a handful of tests/checks, but probably fixing a large number of tests/checks.


  • Seiketsu (Standardisation)

This can be applied to tests/checks (ensuring standard naming conventions are used) but it also applies to toolsets, when having multiple teams on projects, it's important that teams use the same approaches for testing. This is for automated checks (e.g. teams shouldn't be using different tools to automate UI checks) as well as for storing of test cases, reporting bugs. Otherwise it becomes un manageable, if teams start using google docs for tests (don't get me started on that one) and another team is using Microsoft Test Manager, how can anyone have a reasonable idea of what coverage is where across a project.

  • Shutsuke (Sustain)

This is related to ensuring that the above are maintained, being able to reflect on the work you have done and ensure it is up to a standard and meets the appropriate principles that you employ and of course about having the discipline to do all of this.  Don't be too proud, admit mistakes and work on improving them and making sure it doesn't happen again. We are all human, we all make mistakes, grow from it and ensure that you learn from it.

So there we have it, the 5S Methodology applied to testing. I'm sure you could interpret them differently, if you have/can, please comment. I'm interested in hearing what people think.

As I delve further into the book, I'm sure it will prompt more blog posts, so you have that to look forward (?) to :)




Comments

  1. Hey Gareth Waterhouse, i have just bumped into you blog and I must admit that I am in love with it. Your style of writing as well as the information provided if just on another level.

    ReplyDelete

Post a Comment

Popular posts from this blog

Delusions of Testing

So I've got in touch with my old QA friend, Richard Lee and we spoke about guest blogging on each others blogs... Richard is an IT Professional for a FinTech based company in London. His activities vary from Release Manager, Build Manager, Database Administrator. Working in a Microsoft workshop, his expertise lies in MSBuild/Workflow/Powershell/SSAS/SSIS/SSRS/SQL, basically whatever isn’t anyone elses’ problem is Richard's problem! When not solving other peoples problems he can be found blogging at redphoenix.me , and jogging to and from home, where he lives with his heavily pregnant wife. Hello, my name is Richard, and I am a former tester. Like most people and their careers, I fell into testing; I first got into testing about 6 years ago, after I had graduated. I went to a university where the attitude was that you should try to get on a graduate scheme with one of the big companies. If you weren’t interested in that, well, good luck with getting any support from ...

QA is Awesome!

No real point to this post other than I have had the song stuck in my head and figured I could change it slightly and quite easily make QA is Awesome! Oh and I haven't even seen the movie all the way through! But for some reason that song is incredibly catchy! Not much point to this post in fact, just thought I'd put it out there :)

Treating Test Code as Production Code

It's important when writing automated tests to remember that the code you write should be up to production standards, meaning any conventions that you have in place should be adhered to and that it should follow good design patterns. Too many people often say why does it have to be as good as production code, it's "Only" a test, so long as it passes then that's fine... To answer this we need to look at why we want our tests to be written in such a structured and efficient manner: - Maintainability - by making the test code structured and efficient, it becomes far easier to maintain and in doing so changes in the future can happen quickly as the test isn't linked to anything that it shouldn't be and it's easy to understand for a new set of eyes. - Durability - Again by making the tests structured they should be resistant to changes, if you change a variable name for instance then it shouldn't effect the unit test unless it absolutely has to....