[SergeyShatter]

К сожалению я недостаточно хорошо понимаю ООП в JS и как следствие я застрял на написании очередного метода. Речь идет об алгоритме Max Heap. Ниже приведена лишь часть, которой достаточно для реализации метода. Суть задания: Дан набор методов. Необходимо реализовать их интерфейс используя код теста Mocha. В данный момент я застрял на методе swapWithParent(). Подскажите пожалуйста как его реализовать.
Заранее благодарю всех, кто примет участие!

Основной файл:

"use strict";

class Node {
	constructor(data, priority) {
		this.data = data;
		this.priority = priority;
		this.parent = null;
		this.left = null;
		this.right = null;
	}

	appendChild(node) {
        node.parent = this;

        if (this.left && this.right) {
            return;
        }

        if (this.left) {
            this.right = node;
            return;
        }

        this.left = node;
	}

	removeChild(node) {
        if (node == this.left) {
            this.left = null;
        } else if(node == this.right) {
            this.right = null;
        } else return error;

        node.parent = null;
	}

	remove() {
        if (!this.parent) {
            return;
        } else {
            this.parent.removeChild(this);
        }
	}

	swapWithParent() {
		if (!this.parent) {
            return;
        }
        
	}
}

module.exports = Node;

Описание работы метода swapWithParent() в тест файле Mocha:

describe('#swapWithParent', () => {
		it('does nothing if node does not have parent', () => {
			const node = new Node(15, 42);

			expect(() => {
				node.swapWithParent();
			}).not.to.throw();
		});

		it('updates parent.parent', () => {
			const parent = new Node(15, 42);
			const child = new Node(42, 15);

			parent.appendChild(child);
			child.swapWithParent();

			expect(parent.parent).to.equal(child);
		});

		it('updates parent.parent.parent', () => {
			const root = new Node(8, 8);
			const child = new Node(4, 4);
			const grandson = new Node(2, 2);

			root.appendChild(child);
			child.appendChild(grandson);

			grandson.swapWithParent();

			expect(child.parent).to.equal(grandson);
			expect(grandson.parent).to.equal(root);
		});

		it('updates child.parent', () => {
			const parentOfParent = new Node(100, 500);
			const parent = new Node(15, 42);
			const child = new Node(42, 15);

			parentOfParent.appendChild(parent);
			parent.appendChild(child);
			child.swapWithParent();

			expect(child.parent).to.equal(parentOfParent);
		});

		it('updates parent.child.parent', () => {
			const root = new Node(1, 2);
			const left = new Node(3, 4);
			const right = new Node(5, 6);

			root.appendChild(left);
			root.appendChild(right);

			right.swapWithParent();

			expect(left.parent).to.equal(right);
		})

		it('updates children of node and parent node', () => {
			const root = new Node(42, 15);
			const left = new Node(13, 42);
			const right = new Node(0, 1);
			const childOfLeft = new Node(0, 15);

			root.appendChild(left);
			root.appendChild(right);
			left.appendChild(childOfLeft);

			left.swapWithParent();

			expect(left.right).to.equal(right);
			expect(left.left).to.equal(root);
			expect(root.left).to.equal(childOfLeft);
		});

		it('maintains correct state of parent.parent.left and parent.parent.right', () => {
			const root = new Node(15, 42);
			const left = new Node(42, 15);
			const right = new Node(13, 42);
			const childOfLeft = new Node(13, 34);
			const childOfRight = new Node(0, 1);

			root.appendChild(left);
			root.appendChild(right);
			left.appendChild(childOfLeft);
			right.appendChild(childOfRight);

			childOfLeft.swapWithParent();
			childOfRight.swapWithParent();

			expect(root.left).to.equal(childOfLeft);
			expect(root.right).to.equal(childOfRight);
		});
	});