Tuesday, April 15, 2014

a word about Test Case Generation and Cucumber

In previous post "eVidence in action", we have seen, through a demo video, how eVidence will support interactive design. As we were describing the behavior of our web application namely "Simple App", we were getting a global picture of the user navigation flow. This is actually a directed graph that gets automatically updated as we describe our scenarii using a natural language (no scripting, no coding…). If you didn't had a chance to follow it, then please check out this post:  "Link".

This article extends that video and describes more features of eVidence:
- Test case generation tuning by scenario
- Test case generation tuning by data
- Cucumber Step Definition preview

Test Case Generation by Scenario
eVidence embodies a core module named: "Test Generation Engine (TGE)". This engine is called each time we go through the test generation wizard. TGE gives the user more control to adjust the resulting test campaign scope.
By selecting a subset of scenarii, the TGE will output a test campaign based on this subset only. This is actually the first step of the test generation wizard. There's a convenient recap. - in wizard's step 2 - which compares the "full navigation flow" to "selected navigation flow" as illustrated below.

Test Case Generation by Data
The last step of the test case generation wizard is called the data mapping step. We can provide at this point values to scenarii's variables. The TGE will use these mappings to make combinations using Pairwise. 
"Pairwise (a.k.a. all-pairs) testing is an effective test case generation technique that is based on the observation that most faults are caused by interactions of at most two factors. Pairwise-generated test suites cover all combinations of two therefore are much smaller than exhaustive ones yet still very effective in finding defects." - Quote from "http://www.pairwise.org/"
Here below is an illustration of data mappings for the login/password field.

Further information could be added to ensure that the data is relevant to the context of generated test case. Indeed, the context could be adjusted using scenario tags. This aspect will be covered in the future within a dedicated post.

Cucumber step definition
In agile, it's common to use behavior driven development. Cucumber is an awesome testing framework that brightly implements gherkin language to perform user acceptance testing. "Cucumber lets software development teams describe how software should behave in plain text. The text is written in a business-readable domain-specific language and serves as documentation, automated tests and development-aid - all rolled into one format." - Quote from "http://cukes.info/"
eVidence makes it natural to preview Cucumber Step Definition. And this, directly in Java code as illustrated here below for the login scenario.

Hence, it's possible to preview as soon as possible how the step definition would look like. Cucumber helps enforcing a test driven approach within an agile team. It's also a great mean to communicate and synchronize with developers. It's straight forward to copy & paste the java code to our favorite IDE, and implement  acceptance tests to drive the web application under test using Selenium, Selenide or CapyBara .

eVidence is planned to be released early May 2014. I hope that you'll enjoy experiencing it as we'd be pleased to discuss any bugs, suggestions, or questions during upcoming Web-Based Seminar. A communication will be issued as soon as this is scheduled. Register now at "eVidence platform website" to be notified.

Thank you so much for your interest in eVidence and talk to you soon. 

Work With Passion

Saturday, March 1, 2014

eVidence in Action

Either you're working agile or on waterfall projects, we're often experiencing pain with documentation and test case maintenance. It's frequent to experience reading a specification which isn't in synch with the application code base nor related test campaign.

eVidence is a tentative to mitigate this pain. It can help identifying any missing functionality earlier in your application lifecycle. It also makes it straight forward to reuse created scenarii to generate up-to-date test campaigns. 

eVidence enforces re-use over re-work. It centralizes your application behavior to help you take the most out of it.

This video is a short demonstration of eVidence in action:
In coming weeks, There will be a follow-up post describing how we can tune test case generation and generate cucumber test skeletons !

You can sign-up and use it on: 
eVidence Platform Website

May you have any question, feel free to address it at contact@evidence-project.com

Thank you for your time and stay tuned.

Wednesday, January 22, 2014

eVidence - A Solution to Software Testing & Documenting Nightmare using Agile

Here are three problems: keeping requirements up to date, documenting & testing ! These are things we all love to hate. If you're at some point involved in a software development life-cycle, you know what we're talking about. You wish you could deliver a functionality without trading off delay for quality, documentation and testing. But most of the time it's not. Your team goes in quick story writing if you're agile and naturally focus on delivering new features rather than being cautious about testing and documenting. Miscommunication is also a problem as long as requirements are translated into deliverables all along the chain from Product owners to Developers and Testers. Consequences and downsides aren't visible at first, but as you add new features to your product you start experiencing that:
  • Documentation is not easy to browse through.
  • Test maintenance becomes a real issue.
  • Product owners, Business analysts, developers and testers don't speak the same which increases requirements communication and understanding complexity.
Here above, a well known and self-explanatory illustration about the requirement's communication problem. 

I've felt this pain, many times over. So I've decided to build eVidence to cope with all this heavy lifting. I've actually decided to go a step further and make it easy enough for anyone to use, not just developers. If documentation, communication and quality is so interesting to me, why wouldn't it be interesting to anyone else ? the first step toward solving this problem is not just to make things easy, but to help non-developers to easily cooperate with developers while centralizing things to provide valuable third party services. 

So what does the solution looks like ? How can it help you make software management better and focus on delivering more value to project stakeholders.

As the main source of data that mediates between the teams is the app requirements, I've decided to see how Behaviour Driven Development (BDD) and Behaviour Driven Testing (BDT) could help. BDD & BDT solve the problem of domain experts communication by enhancing requirements with acceptance tests called scenarii. Each scenario is an example of how the requirement should behave in a real world situation, seeing a requirement in use helps communication. The scenarii can either be imperative and declarative which provides flexibility while keeping simplicity. Based on Gherkin (Given,When,Then), it enforces the use of a common natural language that can be translated into formal models to generate manual tests or even skeletons for further automation and ad-hoc needs :) 

To support it, eVidence will offer following features and benefits :

  1. Open Rest API that provides services to the different domain experts:
    • Business Analysts: push scenarii to a third party project management system such as Redmine, Trello... 
    • Developers: Get the list of scenarii to automate in order to validate let you use the proper automation mechanism to fit your specific needs such as Cucumber, JBehave, Capybara, Selenium...
    • Testers: the API provides a formal representation of the user flow, which can be used to power Model Based Testing capabilities by using tools such as Graphwalker...

  2. Simple user scenario management interface:
    • Store and share app features and scenarios.
    • Enforce good requirements communication thanks to Gherkin natural language.

  3. Tagging: Easy requirements lookup and browsing.
  5. Test Cases Generation capabilities: Keep your manual and automated tests up to date by generating test cases based on listed scenarii.
Here below is a sum-up illustration of eVidence outputs and interaction with existing products: 

eVidence is the first iteration of a solution to the testing & documentation problem. It's still in beta and I would like to invite you to check it out. I would love your feedback - for bugs, feature suggestions or anything else. Your input will help make eVidence better, so you never have to worry about testing, documenting and quality again :)

In a further post, I'll provide some screenshots of the app in order to give a sneak preview.
Hope to see you eVi-Dencing on the web soon ! 

eVidence Platform - Let's get agile, not fragile :-)