Some recursive models do not require update_forward_refs and silently behave incorrectly

[dmontagu]

Bug

Output of python -c "import pydantic.utils; print(pydantic.utils.version_info())":

             pydantic version: 1.4
            pydantic compiled: False
                 install path: /Users/dmontague/Programming/oss/pydantic/pydantic
               python version: 3.7.4 (default, Oct 17 2019, 23:32:33)  [Clang 11.0.0 (clang-1100.0.33.8)]
                     platform: Darwin-19.0.0-x86_64-i386-64bit
     optional deps. installed: ['typing-extensions', 'email-validator', 'devtools']

This test passes on master, but it should not:

from typing import Optional, Tuple

from pydantic import BaseModel


def test_parse_nested_tuple():
    class NestedTuple(BaseModel):
        x: Tuple[int, Optional["NestedTuple"]]

    obj = NestedTuple.parse_obj({'x': ('1', {'x': ('2', {'x': ('3', None)})})})
    assert obj.dict() == {'x': (1, {'x': ('2', {'x': ('3', None)})})}
    # Note above: the 2 and 3 did not get parsed into ints !!

    NestedTuple.update_forward_refs()
    obj = NestedTuple.parse_obj({'x': ('1', {'x': ('2', {'x': ('3', None)})})})
    assert obj.dict() == {'x': (1, {'x': (2, {'x': (3, None)})})}

Presumably we should either get an error at some point prior to the NestedRootTuple.update_forward_refs() call, or the two calls to obj.dict() should generate the same output.

I'm guessing this is related to the field being Optional, but I'm not sure. I discovered it while working on #1200 .

[samuelcolvin]

yes, very likely related to Optional[]. What happens if you used List['NestedTuple']?

[dmontagu]

Looks like it fails in the same way. This test passes:

from typing import List, Tuple

from pydantic import BaseModel


def test_parse_nested_tuple():
    class NestedTuple(BaseModel):
        x: Tuple[int, List["NestedTuple"]]

    obj = NestedTuple.parse_obj({'x': ('1', [{'x': ('2', [{'x': ('3', [])}])}])})
    assert obj.dict() == {'x': (1, [{'x': ('2', [{'x': ('3', [])}])}])}

    # Note above: the 2 and 3 did not get parsed into ints !!

    NestedTuple.update_forward_refs()
    obj = NestedTuple.parse_obj({'x': ('1', [{'x': ('2', [{'x': ('3', [])}])}])})
    assert obj.dict() == {'x': (1, [{'x': (2, [{'x': (3, [])}])}])}

[matanagasauce]

Looks like a problem of checking ForwardRef. ForwardRef is now checked only in validate_model but not in ModelField.validate, so an error is raised only when ModelField.type_ is calculated ForwardRef. But this doesn't happen to Tuple.
Which means the following test passes

class NestedTuple(BaseModel):
    x: Tuple["NestedTuple"]
obj = NestedTuple.parse_obj({'x': (AnyObject, )})
assert obj.x[0] is AnyObject

Maybe we can move the checking into ModelField to solve this?