Behavior Driven Development (JASMINE)

 Behavior Driven Development (JASMINE)


  BDD and TDD
  BDD and TDD … stand for Behavior-Driven Development and Test-Driven Development.
  TDD in its simplest form is just this:
Ø Write your tests
Ø Watch them fail
Ø Make them pass
Ø Refactor
Ø Repeat
That’s pretty easy to understand, eh?

Introduction

  Behavior Driven Development (BDD) is a software development process that originally emerged from Test Driven Development (TDD).
  The BDD methodology is an extension of test driven development (TDD).
  Both advocate that tests should be written first, which for BDD this means acceptance tests, followed by unit tests driven by the acceptance tests. 
  BDD focus is on capturing the required behavior in User Stories, and from these acceptance tests are written.

  Idea behind BDD
  The idea with acceptance testing is to write tests (or behavioral specifications) that describe the behavior of your software in a language which is not code but is more precise than standard English.
  Doing this allows people who are not software engineers, but have knowledge of the requirements, such as Product Management or Marketing, to write the scenarios that make up our ATs. This is a powerful thing when it comes to capturing the required behavior. 

Different Frameworks Available for BDD


  #1 Mocha
  #2 Jasmine
  #3 Cucumber
  What is KARMA?
  Karma is neither a testing framework nor an assertion library but is a tool that allows you to run your JavaScript test cases.
  Karma supports many JavaScript testing frameworks and Jasmine is one of them.
  Karma also supports running your test cases inside various browsers and through command line.
  You can configure Karma to run locally on your development environment as well as CI (Continuous Integration) Server.
  Why Jasmine
  Jasmine is a behavior-driven development framework for testing JavaScript code that plays very well with Karma. Similar to Karma, it’s also the recommended testing framework within the AngularJS documentation. Jasmine is also dependency free and doesn’t require a DOM.

What a Jasmine Suite Looks Like


  At least one describe block (they can be nested)
  At least one it block which contains a spec
  At least one expectation, which consists of:
  expect which is passed an expression (called the "actual" value)
  A matcher with the expected value (toBe and toBeGreaterThan)

  Suites: describe Your Tests
  Suite’s are like class in object oriented languages like Java, C# which can contain one or more test case methods.
  In Jasmine you can define a suite by calling global Jasmine global function called describe () which takes two arguments.
  The first argument is the name of the suite and the second argument is the JavaScript function containing initialization functions and specs.

Specs
  Spec in Jasmine is a test case which can be defined by calling global Jasmine function called it () which again takes two arguments like suite.
   The first argument is the name of the spec and the second argument is the JavaScript function containing one or more expectations.
  If one run’s any of the spec temporarily then you can declare it as it(), these spec are called pending specs.
 

 Expectations

  Expectation in Jasmine is like assertions. Expectation is built with Jasmine function called expect ().
  Expect function takes a single argument which represents the actual value and compares it to the expected value with the help of a matcher function.
  Jasmine’s matcher functions do Boolean comparison between the actual and the expected values.
  Jasmine framework is loaded with plenty of matchers but if there is a need you can also define you own custom matcher.

Setup and Teardown
  You can implement initialization and cleanup logic inside the Jasmine’s following global functions.
  The beforeEach() is called once before every spec in the describe is executed
  The afterEach() is called once after every spec in the describe is executed
  The beforeAll() is called only once before any of the specs in the describe is executed
  The afterAll() is called after all the specs in the describe are executed 
  Beginner's example: hello world
  What you want to test

function helloWorld() {
return "Hello world!";
}

JASMINE Spec


describe("Hello world", function() {  --  suite  
     it("says hello", function() {  -- spec                              expect(helloWorld()).toEqual("Hello world!"); -- matcher
     });
});



  karma-jasmine-feature 
  I can see no difference between BDD and TDD using JASMINE.

  So if you want to use gherkin langugae BDD, then there  is a Karma plugin that use gherkin feature files to describe tests with Jasmine.
  karma-jasmine-feature 



No comments

Powered by Blogger.