Add / Swap / Shift Left / Right in

const expect = require('chai').expect;
const createList = require('./solution').createList;
let result = null;

describe("Test Operations Over List", () => {
    beforeEach(function(){
        result = createList();
    });

    describe("Add To List", () => {

        it("Add a string", () => {
            result.add("pesho");
            let check = result.toString();
            expect(check).to.be.equal("pesho");
        });

        it("Add a boolean", () => {
            result.add(true);
            let check = result.toString();
            expect(check).to.be.equal("true");
        });

        it("Add numbers", () => {
            result.add(-4.5);
            result.add(5);
            let check = result.toString();
            expect(check).to.be.equal("-4.5, 5");
        });

        it("Add an empty string", () => {
            result.add("");
            let check = result.toString();
            expect(check).to.be.equal("");
        });

        it("No parameter", () => {
            result.add();
            let check = result.toString();
            expect(check).to.be.equal("");
        });
    });

    describe("Shift Left", () => {
        it("Shift left", () => {
            result.add(7);
            result.add([5, 6]);
            result.add("pesho");
            result.shiftLeft();
            let check = result.toString();

            expect(check).to.be.equal("5,6, pesho, 7");
        });

        it("Shift Left to empty array", () => {
            result.shiftLeft();
            let check = result.toString();
            expect(check).to.be.equal("");
        });

        it("Shift Left to array with one element", () => {
            result.add(-5.6);
            result.shiftLeft();
            let check = result.toString();
            expect(check).to.be.equal("-5.6");
        });

        it("Shift Left to array with falsy parameters", () => {
            result.add([]);
            result.add("");
            result.shiftLeft();
            let check = result.toString();
            expect(check).to.be.equal(", ");
        });
    });

    describe("Shift Right", () => {
        it("Shift Right", () => {
            result.add(7);
            result.add([5, 6]);
            result.add("pesho");
            result.shiftRight();
            let check = result.toString();

            expect(check).to.be.equal("pesho, 7, 5,6");
        });

        it("Shift Right to empty array", () => {
            result.shiftRight();
            let check = result.toString();
            expect(check).to.be.equal("");
        });

        it("Shift Right to array with one element", () => {
            result.add(-5.6);
            result.shiftRight();
            let check = result.toString();
            expect(check).to.equal("-5.6");
        });

        it("Shift Right to array with falsy parameters", () => {
            result.add([]);
            result.add("");
            result.shiftRight();
            let check = result.toString();
            expect(check).to.equal(", ");
        });
    });


    describe("Swap", () => {


        it("Swap with parameters strings", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap(5, "gosho");

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameters strings", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap("pesho",5);

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameters numbers, but as strings", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap(2, "1");

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameters numbers, but as strings", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap("1", 5);

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameters numbers, but as strings", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap("2", "1");

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameters decimal numbers", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap(4.5, 2);

            expect(check).to.be.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameters decimal numbers", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap(2, 4.5);

            expect(check).to.be.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });



        it("Swap with negative parameter", () => {
            result.add("true");
            result.add(false);
            result.add(3);
            let returned = result.swap(1, -1);
            let check = result.toString();

            expect(check).to.be.equal("true, false, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with negative parameter", () => {
            result.add("true");
            result.add(false);
            result.add(3);
            let returned = result.swap(-1, 1);
            let check = result.toString();

            expect(check).to.equal("true, false, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with parameter out of range", () => {
            result.add("Monday");
            result.add(-5.6);
            result.add("Ferrari");
            let returned = result.swap(1, 4);
            let check = result.toString();

            expect(check).to.equal("Monday, -5.6, Ferrari");
            expect(returned).to.equal(false);
        });

        it("Swap with parameter out of range", () => {
            result.add("Monday");
            result.add(-5.6);
            result.add("Ferrari");
            let returned = result.swap(4, 1);
            let check = result.toString();

            expect(check).to.equal("Monday, -5.6, Ferrari");
            expect(returned).to.equal(false);
        });

        it("Swap with equal parameters", () => {
            result.add("pesho");
            result.add("gosho");
            result.add(3);
            let returned = result.swap(1, 1);
            let check = result.toString();

            expect(check).to.equal("pesho, gosho, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with valid parameters", () => {
            result.add("pesho");
            result.add(false);
            result.add(3);
            let returned = result.swap(1, 0);
            let check = result.toString();

            expect(check).to.be.equal("false, pesho, 3");
            expect(returned).to.equal(true);
        });

        it("Swap with valid parameters", () => {
            result.add(1);
            result.add(-2);
            result.add(3);
            result.add(4.5);
            let returned = result.swap(3, 1);
            let check = result.toString();

            expect(check).to.be.equal("1, 4.5, 3, -2");
            expect(returned).to.equal(true);
        });

        it("Swap with no parameters", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap();

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });

        it("Swap with only one parameter", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();
            let returned = result.swap(5);

            expect(check).to.equal("7, 12, 3");
            expect(returned).to.equal(false);
        });
    })


/*
describe("swap", function () {
    it('with a negative first index, should return false', function () {
        result.add('one');
        result.add(2);
        expect(result.swap(-5, 1)).to.equal(false);
    });

    it('with a negative first index, should not change the collection', function () {
        result.add('one');
        result.add('two');
        result.swap(-5, 1);
        expect(result.toString()).to.equal("one, two");
    });

    it('with a non integer first index, should return false', function () {
        result.add('one');
        result.add('two');
        expect(result.swap('stamat', 1)).to.equal(false);
    });

    it('with a non integer first index, should not change the collection', function () {
        result.add('one');
        result.add('two');
        result.swap([4, 13], 1);
        expect(result.toString()).to.equal("one, two");
    });

    it('with first index equal to number of elements, should return false', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        expect(result.swap(3, 1)).to.equal(false);
    });

    it('with first index equal to number of elements, should not change the collection', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        result.swap(3, 1);
        expect(result.toString()).to.equal("one, two, three");
    });

    it('with a negative second index, should return false', function () {
        result.add('one');
        result.add(2);
        expect(result.swap(0, -1)).to.equal(false);
    });

    it('with a negative second index, should not change the collection', function () {
        result.add('one');
        result.add('two');
        result.swap(0, -1);
        expect(result.toString()).to.equal("one, two");
    });

    it('with a non integer second index, should return false', function () {
        result.add('one');
        result.add('two');
        expect(result.swap(0, 'stamat')).to.equal(false);
    });

    it('with a non integer second index, should not change the collection', function () {
        result.add('one');
        result.add('two');
        result.swap(0, [4, 13]);
        expect(result.toString()).to.equal("one, two");
    });

    it('with second index equal to number of elements, should return false', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        expect(result.swap(0, 3)).to.equal(false);
    });

    it('with second index equal to number of elements, should not change the collection', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        result.swap(0, 3);
        expect(result.toString()).to.equal("one, two, three");
    });

    it('with equal indexes, should return false', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        expect(result.swap(1, 1)).to.equal(false);
    });

    it('with equal indexes, collection should stay the same', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        result.swap(1, 1);
        expect(result.toString()).to.equal("one, two, three");
    });

    it('with zero first index, should return true', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        expect(result.swap(0, 1)).to.equal(true)
    });

    it('with zero second indexes, should return true', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        expect(result.swap(2, 0)).to.equal(true);
    });

    it('with zero first index, should swap the values', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        result.swap(0, 2);
        expect(result.toString()).to.equal("three, two, one");
    });

    it('with zero second index, should swap the values', function () {
        result.add('one');
        result.add('two');
        result.add('three');
        result.swap(1, 0);
        expect(result.toString()).to.equal("three, two, one");
    });
});
*/

    describe("toString", () => {
        it("toString", () => {
            result.add(7);
            result.add(12);
            result.add(3);
            let check = result.toString();

            expect(check).to.be.equal("7, 12, 3");
        });

        it("toString with empty array", () => {
            let check = result.toString();

            expect(check).to.be.equal("");
        });

        it("toString with boolean", () => {
            result.add(true);
            result.add(false);
            let check = result.toString();

            expect(check).to.be.equal("true, false");
        });

        it("toString with null", () => {
            result.add(null);
            let check = result.toString();

            expect(check).to.be.equal("");
        });

        it("toString with undefined", () => {
            result.add(undefined);
            let check = result.toString();

            expect(check).to.be.equal("");
        });

        it("toString with an object", () => {
            result.add({});
            let check = result.toString();

            expect(check).to.be.equal("[object Object]");
        });
    })
})