7.**Warehouse – Unit Testing

describe('Warehouse', () => {
    function getInstance() {
        return new Warehouse(100);
    }
    it('Test if class properties exists', () => {
        const inst = getInstance();
        expect(Object.getPrototypeOf(inst).hasOwnProperty('capacity')).to.be.equal(true);
        expect(Object.getPrototypeOf(inst).hasOwnProperty('constructor')).to.be.equal(true);
        expect(typeof Warehouse).to.be.equal('function');
    });
    it('capacity to throw with negative num', () => {
        expect(() => {
            const inst = new Warehouse(-100);
        }).to.throw();
    });
    it('capacity to throw with zero', () => {
        expect(() => {
            const inst = new Warehouse(0);
        }).to.throw();
    });
    it("should have a getter property 'capacity'", () => {
        const paymentPackage = getInstance();
        expect(paymentPackage.capacity).to.equal(100);
    });

    it("should have a setter property 'capacity'", () => {
        const paymentPackage = getInstance();
        paymentPackage.capacity = 10;
        expect(paymentPackage.capacity).to.equal(10);
    });
    describe('warehouse add products tests', () => {
        it('add product should add product and return it\'s name', () => {
            const warehouse = getInstance();
            const product = 'rice';
            const type = 'Food';
            const quantity = 5;
            const productObject = {
                rice: quantity,
            };
            const result = warehouse.addProduct(type, product, quantity);
            expect(productObject).to.deep.equal(result);
        });
        it('add product should take right amount of capacity', () => {
            const capacity = 10;
            const warehouse = new Warehouse(capacity);
            const product = 'rice';
            const type = 'Food';
            const quantity = 5;

            warehouse.addProduct(type, product, quantity);
            const takenSpace = warehouse.occupiedCapacity();
            const spaceThatShouldBeTaken = capacity - quantity;
            expect(takenSpace).to.equal(spaceThatShouldBeTaken);
        });

        it('add product should add product and increase its quantity if exists', () => {
            const warehouse = getInstance();
            const product = 'rice';
            const type = 'Food';
            const quantity = 5;

            warehouse.addProduct(type, product, quantity);
            warehouse.addProduct(type, product, quantity);
            const riceQuantity = warehouse.availableProducts.Food[product];
            const expectedQuantity = quantity * 2;
            expect(riceQuantity).to.equal(expectedQuantity);
        });

        it('add product should throw string if not enough capacity', () => {
            expect(() => {
                const warehouse = new Warehouse(5);
                const product = 'rice';
                const type = 'Food';
                const quantity = 10;

                warehouse.addProduct(type, product, quantity);
            }).to.throw('There is not enough space or the warehouse is already full');
        });
    });
    describe('warehouse sort products test', () => {
        it('sort products should sort products of the type descending', () => {
            const warehouse = getInstance();
            const productOne = 'rice';
            const productType = 'Food';
            const productOneQuantity = 10;
            const productTwo = 'bread';
            const productTwoQuantity = 5;
            warehouse.addProduct(productType, productOne, productOneQuantity);
            warehouse.addProduct(productType, productTwo, productTwoQuantity);
            const result = warehouse.orderProducts(productType);
            const expectedOrder = { rice: 10, bread: 5 };
            expect(result).to.deep.equal(expectedOrder);
        });
    });
    describe('warehouse revision tests', () => {
        it('revision should return empty warehouse message', () => {
            const warehouse = getInstance();
            const revision = warehouse.revision();
            const expectedOutput = 'The warehouse is empty';
            expect(revision).to.equal(expectedOutput);
        });

        it('revision should return  ordered list', () => {
            const warehouse = getInstance();
            const productOne = 'rice';
            const productType = 'Food';
            const productTypeTwo = 'Drink';
            const productOneQuantity = 10;
            const productTwo = 'bread';
            const productTwoQuantity = 5;
            warehouse.addProduct(productType, productOne, productOneQuantity);
            warehouse.addProduct(productType, productTwo, productTwoQuantity);
            const revision = warehouse.revision();
            const expectedOutput = `Product type - [${productType}]\n`
                + `- ${productOne} ${productOneQuantity}\n`
                + `- ${productTwo} ${productTwoQuantity}\n`
                + `Product type - [${productTypeTwo}]\n`;
            const expected = expectedOutput.trim();
            expect(revision).to.equal(expected);
        });
    });

    describe('warehouse scrape a product tests', () => {
        it('it should return nonexisting product', () => {
            const noneExistingType = 'wine';
            const expectedResult = `${noneExistingType} do not exists`;
            expect(() => {
                const warehouse = getInstance();
                const productOne = 'rice';
                const productType = 'Food';
                const productOneQuantity = 10;
                const productTwo = 'bread';
                const productTwoQuantity = 5;
                warehouse.addProduct(productType, productOne, productOneQuantity);
                warehouse.addProduct(productType, productTwo, productTwoQuantity);
                warehouse.scrapeAProduct(noneExistingType, 5);
            }).to.throw(expectedResult);
        });

        it('it should reset amount of the product with not enough quantity', () => {
            const warehouse = getInstance();
            const product = 'rice';
            const productType = 'Food';
            const productQuantity = 5;
            const productWantedQuantity = 10;
            warehouse.addProduct(productType, product, productQuantity);
            warehouse.scrapeAProduct(product, productWantedQuantity);
            const currentCountProduct = warehouse.availableProducts.Food[product];
            const expectedCount = 0;
            expect(currentCountProduct).to.equal(expectedCount);
        });

        it('it should return correct quantity of the product', () => {
            const warehouse = getInstance();
            const product = 'rice';
            const productType = 'Food';
            const productQuantity = 10;
            const productWantedQuantity = 5;
            warehouse.addProduct(productType, product, productQuantity);
            warehouse.scrapeAProduct(product, productWantedQuantity);
            const currentCountProduct = warehouse.availableProducts.Food[product];
            const expectedCount = 5;
            expect(currentCountProduct).to.equal(expectedCount);
        });
    });
});