tzatziki

tzatziki

A domain rules engine based on Gherkin syntax

WARNING: this project is still highly experimental and its API may change in the future!

NOTE: while experimental, feedback is encouraged and really welcome!

Why?

The Gherkin syntax and the cucumber project have made writing and execuring acceptance tests a very easy and efficient activity.

However, writing the real domain code could still be a very complex and risking challenge.

In a LEAN and Agile world, requirements may change a lot along the development lifecycle. The impact of complex code refactoring can be devastating for teams, companies and client's investment.

That's the idea: why don't model the domain logic using the same approach used to write the acceptance tests?

The main advantages of this approach are:

• Complex code is implicitly broken in small and resusable step definitions.
• The cost of requirement changes become less critical and the investment more valuable.
• Throwing away big chunks of code when requirements change is less probable.
• The domain code is highly decoupled from the rest of the system, making it more clean and visible.

Getting started

First of all, let's install Tzatziki:

$ npm install --save tzatziki

We can now create features and scenarios using the Tzatziki API:

const Tzatziki = require('tzatziki')
const tzatziki = new Tzatziki()

// Create a feature for our business domain:

const feature = tzatziki.createFeature('User profile', 'As user, I request my profile details')
const scenario = feature.createScenario('A user requests her profile')

scenario.Given('a user')
scenario.When('she requests her profile')
scenario.Then('her details are returned')

// Then, populate the dictionary of definitions to provide the logic:

tzatziki.dictionary.Given('a user', function () { ... })
tzatziki.dictionary.When('she requests her profile', function () { ... })
tzatziki.dictionary.Then('her details are returned', function () { ... })

feature
  .exec(tzatziki.dictionary)
  .catch(err => console.log(err))

Alternatively, we can also use features written in Gherkin syntax to model our domain logic:

const Tzatziki = require('tzatziki')
const tzatziki = new Tzatziki()

// Cucumber-style methods can be used:

const { Given, When, Then } = tzatziki.cucumber()

Given('a user', function () { ... })
When('she requests her profile', function () { ... })
Then('her details are returned', function () { ... })

// Parse an existing feature file:

tzatziki
  .parse('features/example.feature')
  .then(feature => feature.exec(tzatziki.dictionary))

Test

$ npm test

Acknowledgements

This project is kindly sponsored by:

License

Licensed under MIT