def test_build_list_property_invalid_items(self, mocker):
        from openapi_python_client.parser import properties

        name = "name"
        required = mocker.MagicMock()
        data = oai.Schema(
            type="array",
            items={},
        )
        schemas = properties.Schemas()
        second_schemas = properties.Schemas(errors=["error"])
        property_from_data = mocker.patch.object(
            properties,
            "property_from_data",
            return_value=(properties.PropertyError(data="blah"),
                          second_schemas))
        config = MagicMock()

        p, new_schemas = properties.build_list_property(name=name,
                                                        required=required,
                                                        data=data,
                                                        schemas=schemas,
                                                        parent_name="parent",
                                                        config=config)

        assert p == PropertyError(
            data="blah", detail=f"invalid data in items of array {name}")
        assert new_schemas == second_schemas
        assert schemas != new_schemas, "Schema was mutated"
        property_from_data.assert_called_once_with(name=f"{name}_item",
                                                   required=True,
                                                   data=data.items,
                                                   schemas=schemas,
                                                   parent_name="parent",
                                                   config=config)
    def test_build_list_property(self, mocker):
        from openapi_python_client.parser import properties

        name = "prop"
        required = mocker.MagicMock()
        data = oai.Schema(
            type="array",
            items={},
        )
        schemas = properties.Schemas()
        second_schemas = properties.Schemas(errors=["error"])
        property_from_data = mocker.patch.object(
            properties, "property_from_data", return_value=(mocker.MagicMock(), second_schemas)
        )
        mocker.patch("openapi_python_client.utils.snake_case", return_value=name)
        mocker.patch("openapi_python_client.utils.to_valid_python_identifier", return_value=name)
        config = MagicMock()

        p, new_schemas = properties.build_list_property(
            name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=config
        )

        assert isinstance(p, properties.ListProperty)
        assert p.inner_property == property_from_data.return_value[0]
        assert new_schemas == second_schemas
        assert schemas != new_schemas, "Schema was mutated"
        property_from_data.assert_called_once_with(
            name=f"{name}_item", required=True, data=data.items, schemas=schemas, parent_name="parent", config=config
        )
    def test_build_list_property_no_items(self, mocker):
        from openapi_python_client.parser import properties

        name = mocker.MagicMock()
        required = mocker.MagicMock()
        data = oai.Schema.construct(type="array")
        property_from_data = mocker.patch.object(properties, "property_from_data")
        schemas = properties.Schemas()

        p, new_schemas = properties.build_list_property(
            name=name, required=required, data=data, schemas=schemas, parent_name="parent", config=MagicMock()
        )

        assert p == PropertyError(data=data, detail="type array must have items defined")
        assert new_schemas == schemas
        property_from_data.assert_not_called()
    def test_build_list_property(self, any_property_factory):
        from openapi_python_client.parser import properties

        name = "prop"
        data = oai.Schema(
            type="array",
            items={},
        )
        schemas = properties.Schemas(errors=["error"])
        config = Config()

        p, new_schemas = properties.build_list_property(
            name=name, required=True, data=data, schemas=schemas, parent_name="parent", config=config
        )

        assert isinstance(p, properties.ListProperty)
        assert p.inner_property == any_property_factory(name=f"{name}_item")
        assert new_schemas == schemas