Не проходят проверку тесты по функционалу бинарного дерева

Код бинарного дерева написал:

class Node:

    def __init__(self, data):
        self.data = data
        self.left = self.right = None


class Tree:

    def __init__(self):
        self.root = None

    def __find(self, node, parent, value):

        if node is None:
            return None, parent, False

        if value == node.data:
            return node, parent, True

        if value < node.data:
            if node.left:
                return self.__find(node.left, node, value)

        if value > node.data:
            if node.right:
                return self.__find(node.right, node, value)

        return node, parent, False

    def append(self, obj):


        if self.root is None:
            self.root = obj
            return obj

        s, p, fl_find = self.__find(self.root, None, obj.data)

        if not fl_find and s:
            if obj.data < s.data:
                s.left = obj
            else:
                s.right = obj

        return obj

    def show_tree(self, node):

        if node is None:
            return

        self.show_tree(node.left)
        print(node.data)
        self.show_tree(node.right)

    def show_wide_tree(self, node):

        if node is None:
            return
        v = [node]
        while v:
            vn = []
            for x in v:
                print(x.data, end=' ')
                if x.left:
                    vn +=[x.left]
                if x.right:
                    vn +=[x.right]
            print()
            v = vn

    def __del_leaf(self, s, p):

        if p.left == s:
            p.left = None
        elif p.right == s:
            p.right = None

    def __del_one_child(self, s, p):

        if p.left == s:
            if s.left is None:
                p.left = s.right
            elif s.right is None:
                p.left = s.left

        elif p.right == s:
            if s.left is None:
                p.right = s.right
            elif s.right is None:
                p.right = s.left

    def __find_min(self, node, parent):

        if node.left:
            return self.__find_min(node.left, node)

        return node, parent

    def del_node(self, key):

        s, p, fl_find = self.__find(self.root, None, key)
        if not fl_find:
            return None
        if s.left is None and s.right is None:
            self.__del_leaf(s, p)
        elif s.left is None or s.right is None:
            self.__del_one_child(s, p)
        else:
            sr, pr = self.__find_min(s.right, s)
            s.data = sr.data
            self.__del_one_child(sr, pr)

    def min_node(self):

        node = self.root
        data = node.data
        while node:
            data = node.data
            node = node.left
        return data

    def max_node(self):

        node = self.root
        data = node.data
        while node:
            data = node.data
            node = node.right
        return data



t = Tree()
for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]:
    t.append(Node(x))

t.del_node(14)
t.show_tree(t.root)
t.show_wide_tree(t.root)
print(t.min_node())
print(t.max_node())

Проверочные тесты написал:

import pytest
from binary_tree import Tree, Node


def test_append_True():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]:
        t.append(Node(x))
    assert t.root == [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]


def test_append_False():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58, 25]:
        t.append(Node(x))
    assert t.root != [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58, 58]


def test_del():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 20, 58]:
        t.append(Node(x))
    t.del_node(20)
    assert t.root == [54, 5, 7, 16, 13, 2, 14, 58]


def test_min_True():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]:
        t.append(Node(x))
    assert t.min_node() == 2


def test_min_False():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]:
        t.append(Node(x))
    assert t.min_node() != 3


def test_max_True():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]:
        t.append(Node(x))
    assert t.max_node() == 58


def test_max_False():
    t = Tree()
    for x in [54, 5, 7, 16, 13, 2, 20, 14, 14, 20, 58]:
        t.append(Node(x))
    assert t.max_node() != 60

Но при проверки не проходят тесты по добавлению и удалению, проверка максимального и минимального значения проходят? В чем ошибка?