Coverage for tests / test_aliases.py: 100%

1import pytest 8 ctx1abcdefgh

2from pydantic import BaseModel, ValidationError 8 ctx1abcdefgh

3from pydantic import Field as PField 8 ctx1abcdefgh

4from sqlmodel import Field, SQLModel 8 ctx1abcdefgh

5 

6""" 8 ctx1abcdefgh

7Alias tests for SQLModel and Pydantic compatibility 

8""" 

9 

10 

11class PydanticUser(BaseModel): 8 ctx1abcdefgh

12 full_name: str = PField(alias="fullName") 8 ctx1abcdefgh

13 

14 

15class SQLModelUser(SQLModel): 8 ctx1abcdefgh

16 full_name: str = Field(alias="fullName") 8 ctx1abcdefgh

17 

18 

19# Models with config (validate_by_name=True) 

20class PydanticUserWithConfig(PydanticUser): 8 ctx1abcdefgh

21 model_config = {"validate_by_name": True} 8 ctx1abcdefgh

22 

23 

24class SQLModelUserWithConfig(SQLModelUser): 8 ctx1abcdefgh

25 model_config = {"validate_by_name": True} 8 ctx1abcdefgh

26 

27 

28@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 8 ctx1abcdefgh

29def test_create_with_field_name(model: type[PydanticUser] | type[SQLModelUser]): 8 ctx1abcdefgh

30 with pytest.raises(ValidationError): 8 ctx2~ abbbcbdbebfbgb

31 model(full_name="Alice") 8 ctx2~ abbbcbdbebfbgb

32 

33 

34@pytest.mark.parametrize("model", [PydanticUserWithConfig, SQLModelUserWithConfig]) 8 ctx1abcdefgh

35def test_create_with_field_name_with_config( 8 ctx1abcdefgh

36 model: type[PydanticUserWithConfig] | type[SQLModelUserWithConfig], 

37): 

38 user = model(full_name="Alice") 8 ctx2hbibjbkblbmbnbob

39 assert user.full_name == "Alice" 8 ctx2hbibjbkblbmbnbob

40 

41 

42@pytest.mark.parametrize( 8 ctx1abcdefgh

43 "model", 

44 [PydanticUser, SQLModelUser, PydanticUserWithConfig, SQLModelUserWithConfig], 

45) 

46def test_create_with_alias( 8 ctx1abcdefgh

47 model: type[PydanticUser] 

48 | type[SQLModelUser] 

49 | type[PydanticUserWithConfig] 

50 | type[SQLModelUserWithConfig], 

51): 

52 user = model(fullName="Bob") # using alias 8 ctx2pbqbrbsbtbubvbwb

53 assert user.full_name == "Bob" 8 ctx2pbqbrbsbtbubvbwb

54 

55 

56@pytest.mark.parametrize("model", [PydanticUserWithConfig, SQLModelUserWithConfig]) 8 ctx1abcdefgh

57def test_create_with_both_prefers_alias( 8 ctx1abcdefgh

58 model: type[PydanticUserWithConfig] | type[SQLModelUserWithConfig], 

59): 

60 user = model(full_name="IGNORED", fullName="Charlie") 8 ctx2xbybzbAbBbCbDbEb

61 assert user.full_name == "Charlie" # alias should take precedence 8 ctx2xbybzbAbBbCbDbEb

62 

63 

64@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 8 ctx1abcdefgh

65def test_dict_default_uses_field_names( 8 ctx1abcdefgh

66 model: type[PydanticUser] | type[SQLModelUser], 

67): 

68 user = model(fullName="Dana") 8 ctx1WXYZ0123

69 data = user.model_dump() 8 ctx1WXYZ0123

70 assert "full_name" in data 8 ctx1WXYZ0123

71 assert "fullName" not in data 8 ctx1WXYZ0123

72 assert data["full_name"] == "Dana" 8 ctx1WXYZ0123

73 

74 

75@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 8 ctx1abcdefgh

76def test_dict_by_alias_uses_aliases( 8 ctx1abcdefgh

77 model: type[PydanticUser] | type[SQLModelUser], 

78): 

79 user = model(fullName="Dana") 8 ctx1456789!#

80 data = user.model_dump(by_alias=True) 8 ctx1456789!#

81 assert "fullName" in data 8 ctx1456789!#

82 assert "full_name" not in data 8 ctx1456789!#

83 assert data["fullName"] == "Dana" 8 ctx1456789!#

84 

85 

86@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 8 ctx1abcdefgh

87def test_json_by_alias( 8 ctx1abcdefgh

88 model: type[PydanticUser] | type[SQLModelUser], 

89): 

90 user = model(fullName="Frank") 8 ctx1$%'()*+,

91 json_data = user.model_dump_json(by_alias=True) 8 ctx1$%'()*+,

92 assert ('"fullName":"Frank"' in json_data) or ('"fullName": "Frank"' in json_data) 8 ctx1$%'()*+,

93 assert "full_name" not in json_data 8 ctx1$%'()*+,

94 

95 

96class PydanticUserV2(BaseModel): 8 ctx1abcdefgh

97 first_name: str = PField(validation_alias="firstName", serialization_alias="f_name") 8 ctx1abcdefgh

98 

99 

100class SQLModelUserV2(SQLModel): 8 ctx1abcdefgh

101 first_name: str = Field(validation_alias="firstName", serialization_alias="f_name") 8 ctx1abcdefgh

102 

103 

104@pytest.mark.parametrize("model", [PydanticUserV2, SQLModelUserV2]) 8 ctx1abcdefgh

105def test_create_with_validation_alias( 8 ctx1abcdefgh

106 model: type[PydanticUserV2] | type[SQLModelUserV2], 

107): 

108 user = model(firstName="John") 8 ctx2FbGbHbIbJbKbLbMb

109 assert user.first_name == "John" 8 ctx2FbGbHbIbJbKbLbMb

110 

111 

112@pytest.mark.parametrize("model", [PydanticUserV2, SQLModelUserV2]) 8 ctx1abcdefgh

113def test_serialize_with_serialization_alias( 8 ctx1abcdefgh

114 model: type[PydanticUserV2] | type[SQLModelUserV2], 

115): 

116 user = model(firstName="Jane") 8 ctx1OPQRSTUV

117 data = user.model_dump(by_alias=True) 8 ctx1OPQRSTUV

118 assert "f_name" in data 8 ctx1OPQRSTUV

119 assert "firstName" not in data 8 ctx1OPQRSTUV

120 assert "first_name" not in data 8 ctx1OPQRSTUV

121 assert data["f_name"] == "Jane" 8 ctx1OPQRSTUV

122 

123 

124def test_schema_extra_validation_alias_sqlmodel_v2(): 8 ctx1abcdefgh

125 class M(SQLModel): 8 ctx1-./:;=?@

126 f: str = Field(schema_extra={"validation_alias": "f_alias"}) 8 ctx1-./:;=?@

127 

128 m = M.model_validate({"f_alias": "asd"}) 8 ctx1-./:;=?@

129 assert m.f == "asd" 8 ctx1-./:;=?@

130 

131 

132def test_schema_extra_serialization_alias_sqlmodel_v2(): 8 ctx1abcdefgh

133 class M(SQLModel): 8 ctx1ijklmnop

134 f: str = Field(schema_extra={"serialization_alias": "f_out"}) 8 ctx1ijklmnop

135 

136 m = M(f="x") 8 ctx1ijklmnop

137 data = m.model_dump(by_alias=True) 8 ctx1ijklmnop

138 assert "f_out" in data 8 ctx1ijklmnop

139 assert "f" not in data 8 ctx1ijklmnop

140 assert data["f_out"] == "x" 8 ctx1ijklmnop

141 

142 

143def test_alias_plus_validation_alias_prefers_validation_alias_sqlmodel_v2(): 8 ctx1abcdefgh

144 class M(SQLModel): 8 ctx1[]^_`{|}

145 first_name: str = Field(alias="fullName", validation_alias="v_name") 8 ctx1[]^_`{|}

146 

147 m = M.model_validate({"fullName": "A", "v_name": "B"}) 8 ctx1[]^_`{|}

148 assert m.first_name == "B" 8 ctx1[]^_`{|}

149 

150 

151def test_alias_plus_serialization_alias_prefers_serialization_alias_sqlmodel_v2(): 8 ctx1abcdefgh

152 class M(SQLModel): 8 ctx1qrstuvwx

153 first_name: str = Field(alias="fullName", serialization_alias="f_name") 8 ctx1qrstuvwx

154 

155 m = M(fullName="Z") 8 ctx1qrstuvwx

156 data = m.model_dump(by_alias=True) 8 ctx1qrstuvwx

157 assert "f_name" in data 8 ctx1qrstuvwx

158 assert "fullName" not in data 8 ctx1qrstuvwx

159 assert data["f_name"] == "Z" 8 ctx1qrstuvwx

160 

161 

162def test_alias_generator_works_sqlmodel_v2(): 8 ctx1abcdefgh

163 class M(SQLModel): 8 ctx1yzABCDEF

164 model_config = {"alias_generator": lambda s: "gen_" + s} 8 ctx1yzABCDEF

165 f: str = Field() 8 ctx1yzABCDEF

166 

167 m = M.model_validate({"gen_f": "ok"}) 8 ctx1yzABCDEF

168 assert m.f == "ok" 8 ctx1yzABCDEF

169 data = m.model_dump(by_alias=True) 8 ctx1yzABCDEF

170 assert "gen_f" in data and data["gen_f"] == "ok" 8 ctx1yzABCDEF

171 

172 

173def test_alias_generator_with_explicit_alias_prefers_field_alias_sqlmodel_v2(): 8 ctx1abcdefgh

174 class M(SQLModel): 8 ctx1GHIJKLMN

175 model_config = {"alias_generator": lambda s: "gen_" + s} 8 ctx1GHIJKLMN

176 f: str = Field(alias="custom") 8 ctx1GHIJKLMN

177 

178 m = M.model_validate({"custom": "ok"}) 8 ctx1GHIJKLMN

179 assert m.f == "ok" 8 ctx1GHIJKLMN

180 data = m.model_dump(by_alias=True) 8 ctx1GHIJKLMN

181 assert "custom" in data and "gen_f" not in data 8 ctx1GHIJKLMN