var scenario = require('gerbil').scenario;
 
scenario("Testing with node", {
  "should work in a terminal": function(g){
    g.assert(true);
  }
});
 
// Or if you want to access some global Gerbil stuff
 
var Gerbil = require('gerbil');
var scenario = Gerbil.scenario;

// Name the scenario you want to test and pass an object with your tests.
scenario("Some useful stuff that needs to work", {
  // Reserved names are 'setup', 'before', 'after' and 'cleanup'. They define
  // the steps to be executed.
  //
  // Every test gets one parameter, this is the test suite itself.
  // Modifying 'this' will affect the context in the tests, it's useful when
  // using 'setup' to initialize some state.
  'setup': function(g) {
    this.validName = 'Gerbil';
  },
  // Within the test 'this' gets the config defined in 'setup'
  'should get the correct name': function(g) {
    g.assertEqual(this.validName, 'Gerbil');
  },
 
  // Test in the feature, useful to test future events or timers.
  'in the future': function(g) {
    this.time = new Date().getTime();
 
    g.setTimeout(function() {
      g.assert(new Date().getTime() > this.time);
    }, 1000);
  },
 
  // Test async code.
  //
  // Using the async function you can control the status of the test. This is
  // really useful when you are testing callbacks.
  // But remember, it's your responsability to end() the test.
  'should be able to test asyncronous code': function(g) {
    var asyncStuff = function() {
      this.callback = null;
    };
 
    asyncStuff.prototype = {
      eventually: function(fn) {
        this.callback = fn;
      },
 
      exec: function() {
        setTimeout(function(c) {
          c.callback();
        }, 500, this);
      }
    };
 
    g.async(function() {
      var async = new asyncStuff;
      async.eventually(function() {
        g.assert(true);
        // end() will end the current scenario and trigger a summary
        g.end();
      });
      async.exec();
    });
  }
 
});

scenario("This is my scenario", {
  "setup":  function() {
    // When scenario starts
    this.someThing = new Thing;
  },
  "before": function() {
    // Before every test
    this.someThing.magic_magic();
  },
  "after":  function() {
    // After every test
    this.someThing.clean();
  },
  "cleanup": function() {
    // When the scenario ends
    this.someThing = false;
  },
 
  "MagicThing should have a length": function(g) {
    this.someThing.add(1);
    g.assertEqual(this.someThing.length, 1);
  },
 
  "MagicThing should be valid": function(g) {
    g.assert(this.someThing.valid);
  }
});

var myCoolFormatter = {
  // Passing tests
  "ok": function(msg) {},
 
  // Failing tests
  "fail": function(msg) {},
 
  // Pending tests
  "pending": function(msg) {},
 
  // The start of a scenario
  "scenario": function(msg) {},
 
  // Report at the end of a scenario
  "summary": function(msg) {}
};
 
scenario("Fancy scenario", {
  "config": function(c) {
    c.formatter = myCoolFormatter;
  },
  "somewhere over the rainbow": function(g) {
    g.assert(false);
  }
});
 
// Or if you want to affect every gerbil scenario
 
Gerbil.globalConfig = {
  formatter: myCoolFormatter
}

scenario('configuration', {
  'config': function(c) {
    c.start = function(object) {};
    c.finish = function(results) {};
  }
});
 
// Of course you can define then globally:
 
Gerbil.globalConfig = {
  start: function(object) {},
  finish: function(results) {}
};