declare var describe, it, require, before;
import IBusiness    = require("../../src/business/iBusiness");
import IDataAccess  = require("../../src/dataAccess/iDataAccess");
import Disability   = require("../../src/domain/entity/disability");
import User         = require("../../src/domain/entity/user");
import UserBusiness = require("../../src/business/userBusiness");

var Assert = require("assert");

var business: IBusiness, mockedData: any;
var mail: string = (new Date()).toISOString();

class MockUserDataAccess implements IDataAccess {
    public create (data: any): User {
        data.status = true;
        data._id = "";
        return data;
    }
    public retrieve (email?: string): User | User[] {
        var data = [ new User("test", mail, "123456", true, true, Disability.BLINDNESS, 3) ];
        return (email===undefined)? data : (email===data[0].getEmail())? data[0] : null;
    }
    public update (email: string, data: any): User {
        var user: User = new User("test", mail, "123456", true, true, Disability.BLINDNESS, 3);
        if(email===mail){
            user.setName(data.name);
            return user;
        } else {
            return null;
        } }
    public delete (email: string): boolean { return (email===mail); }
}

describe("UserBusiness", () => {

    before(() => {
        business = new UserBusiness(new MockUserDataAccess());
        mockedData = {
            name: "test",
            email: mail,
            password: "123456",
            disabled: true,
            helper: true,
            disability: Disability.BLINDNESS,
            disabilityLevel: 3
        };
    });

    it("should return the response from dataAccess after create procedure", (done) => {
        var current: User = business.create(mockedData);
        var expected: User = new User("test", mail, "123456", true, true, Disability.BLINDNESS, 3, true, "");
        Assert.deepEqual(current, expected);
        done();
    });

    it("should retrieve the User list from the dataAccess", (done) => {
        var expected: User[] = [ new User("test", mail, "123456", true, true, Disability.BLINDNESS, 3) ];
        var current: User[] = business.retrieve();
        Assert.deepEqual(current, expected);
        done();
    });

    it("should retrieve the correct User given his email", (done) => {
        var expected: string = mail;
        var current: User = business.retrieve(expected);
        Assert.equal(current.getEmail(), expected);
        done();
    });

    it("should fail to retrieve a User given an unknown email", (done) => {
        var expected: User = null;
        var current: User = business.retrieve("wrong@mail.com");
        Assert.equal(current, expected);
        done();
    });

    it("should update User's name", (done) => {
        var email = mail;
        var data: any = { name: "New Name" };
        var expected: string = "New Name";
        var current: User = business.update(email, data);
        Assert.equal(current.getName(), expected);
        done();
    });

    it("should remove the User from the repository", (done) => {
        var expected: boolean = true;
        var current: boolean = business.delete(mail);
        Assert.equal(current, expected);
        done();
    });

    it("should fail removing the User due to unknown email", (done) => {
        var expected: boolean = false;
        var current: boolean = business.delete("wrong@mail.com");
        Assert.equal(current, expected);
        done();
    });
});