/*jshint node:true */

/*global describe:false, it:false */

"use strict";

var sequence = require('../');

var should = require('should');

require('mocha');

describe('task sequencing', function() {

	describe('sequence()', function() {

		var dependencyTree = {

			a: [],

			b: ['a'],

			c: ['a'],

			d: ['b','c'],

			e: ['f'],

			f: ['e'],

			g: ['g']

		};

		var noop = function () {};

		var makeTasks = function (tree) {

			var tasks = {}, p;

			for (p in tree) {

				if (tree.hasOwnProperty(p)) {

					tasks[p] = {

						name: p,

						dep: tree[p],

						fn: noop

					};

				}

			}

			return tasks;

		};

		var theTest = function (source,expected) {

			// Arrange

			var tasks = makeTasks(dependencyTree);

			var actual = [];

			// Act

			sequence(tasks, source.split(','), actual);

			// Assert

			actual.join(',').should.equal(expected);

		};

		it('a -> a', function() {

			theTest('a', 'a');

		});

		it('a,a -> a', function() {

			theTest('a,a', 'a');

		});

		it('c -> a,c', function() {

			theTest('c', 'a,c');

		});

		it('b -> a,b', function() {

			theTest('b', 'a,b');

		});

		it('c,b -> a,c,b', function() {

			theTest('c,b', 'a,c,b');

		});

		it('b,c -> a,b,c', function() {

			theTest('b,c', 'a,b,c');

		});

		it('b,a -> a,b', function() {

			theTest('b,a', 'a,b');

		});

		it('d -> a,b,c,d', function() {

			theTest('d', 'a,b,c,d');

		});

		it('c,d -> a,c,b,d', function() {

			theTest('c,d', 'a,c,b,d');

		});

		it('b,d -> a,b,c,d', function() {

			theTest('b,d', 'a,b,c,d');

		});

		it('e -> throw', function() {

			var failed = false, i;

			var expectedRecursionList = ['e','f','e'];

			var expectedTaskList = ['a','b','c','d','e','f','g'];

			try {

				theTest('e', 'throw');

				failed = true;

			} catch (err) {

				should.exist(err);

				err.message.should.match(/recursive/i, err.message+' should include recursive');

				err.recursiveTasks.length.should.equal(expectedRecursionList.length);

				for (i = 0; i < expectedRecursionList.length; i++) {

					err.recursiveTasks[i].should.equal(expectedRecursionList[i]);

				}

				err.taskList.length.should.equal(expectedTaskList.length);

				expectedTaskList.forEach(function (item) {

					err.taskList.should.include(item);

				});

			}

			failed.should.equal(false);

		});

		it('g -> throw', function() {

			var failed = false, i;

			var expectedRecursionList = ['g','g'];

			var expectedTaskList = ['a','b','c','d','e','f','g'];

			try {

				theTest('g', 'throw');

				failed = true;

			} catch (err) {

				should.exist(err);

				err.message.should.match(/recursive/i, err.message+' should include recursive');

				err.recursiveTasks.length.should.equal(expectedRecursionList.length);

				for (i = 0; i < expectedRecursionList.length; i++) {

					err.recursiveTasks[i].should.equal(expectedRecursionList[i]);

				}

				err.taskList.length.should.equal(expectedTaskList.length);

				expectedTaskList.forEach(function (item) {

					err.taskList.should.include(item);

				});

			}

			failed.should.equal(false);

		});

		it('h -> throw', function() {

			var failed = false;

			var expectedTaskList = ['a','b','c','d','e','f','g'];

			try {

				theTest('h', 'throw');

				failed = true;

			} catch (err) {

				should.exist(err);

				err.message.should.match(/not defined/i, err.message+' should include not defined');

				err.missingTask.should.equal('h');

				err.taskList.length.should.equal(expectedTaskList.length);

				expectedTaskList.forEach(function (item) {

					err.taskList.should.include(item);

				});

			}

			failed.should.equal(false);

		});

	});

});