Coverage for tests / test_aliases.py: 100%

108 statements  

« prev     ^ index     » next       coverage.py v7.13.0, created at 2026-01-06 21:09 +0000

1from typing import Union 1abcidefgh

2 

3import pytest 1abcidefgh

4from pydantic import BaseModel, ValidationError 1abcidefgh

5from pydantic import Field as PField 1abcidefgh

6from sqlmodel import Field, SQLModel 1abcidefgh

7 

8""" 1abcdefgh

9Alias tests for SQLModel and Pydantic compatibility 

10""" 

11 

12 

13class PydanticUser(BaseModel): 1abcidefgh

14 full_name: str = PField(alias="fullName") 1abcidefgh

15 

16 

17class SQLModelUser(SQLModel): 1abcidefgh

18 full_name: str = Field(alias="fullName") 1abcidefgh

19 

20 

21# Models with config (validate_by_name=True) 

22class PydanticUserWithConfig(PydanticUser): 1abcidefgh

23 model_config = {"validate_by_name": True} 1abcidefgh

24 

25 

26class SQLModelUserWithConfig(SQLModelUser): 1abcidefgh

27 model_config = {"validate_by_name": True} 1abcidefgh

28 

29 

30@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 1abcidefgh

31def test_create_with_field_name(model: Union[type[PydanticUser], type[SQLModelUser]]): 1abcidefgh

32 with pytest.raises(ValidationError): 2kblbmbnbobpbqbrbsb

33 model(full_name="Alice") 2kblbmbnbobpbqbrbsb

34 

35 

36@pytest.mark.parametrize("model", [PydanticUserWithConfig, SQLModelUserWithConfig]) 1abcidefgh

37def test_create_with_field_name_with_config( 1abcidefgh

38 model: Union[type[PydanticUserWithConfig], type[SQLModelUserWithConfig]], 

39): 

40 user = model(full_name="Alice") 2tbubvbwbxbybzbAbBb

41 assert user.full_name == "Alice" 2tbubvbwbxbybzbAbBb

42 

43 

44@pytest.mark.parametrize( 1abcidefgh

45 "model", 

46 [PydanticUser, SQLModelUser, PydanticUserWithConfig, SQLModelUserWithConfig], 

47) 

48def test_create_with_alias( 1abcidefgh

49 model: Union[ 

50 type[PydanticUser], 

51 type[SQLModelUser], 

52 type[PydanticUserWithConfig], 

53 type[SQLModelUserWithConfig], 

54 ], 

55): 

56 user = model(fullName="Bob") # using alias 2CbDbEbFbGbHbIbJbKb

57 assert user.full_name == "Bob" 2CbDbEbFbGbHbIbJbKb

58 

59 

60@pytest.mark.parametrize("model", [PydanticUserWithConfig, SQLModelUserWithConfig]) 1abcidefgh

61def test_create_with_both_prefers_alias( 1abcidefgh

62 model: Union[type[PydanticUserWithConfig], type[SQLModelUserWithConfig]], 

63): 

64 user = model(full_name="IGNORED", fullName="Charlie") 2LbMbNbObPbQbRbSbTb

65 assert user.full_name == "Charlie" # alias should take precedence 2LbMbNbObPbQbRbSbTb

66 

67 

68@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 1abcidefgh

69def test_dict_default_uses_field_names( 1abcidefgh

70 model: Union[type[PydanticUser], type[SQLModelUser]], 

71): 

72 user = model(fullName="Dana") 123456789!

73 data = user.model_dump() 123456789!

74 assert "full_name" in data 123456789!

75 assert "fullName" not in data 123456789!

76 assert data["full_name"] == "Dana" 123456789!

77 

78 

79@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 1abcidefgh

80def test_dict_by_alias_uses_aliases( 1abcidefgh

81 model: Union[type[PydanticUser], type[SQLModelUser]], 

82): 

83 user = model(fullName="Dana") 1#$%'()*+,

84 data = user.model_dump(by_alias=True) 1#$%'()*+,

85 assert "fullName" in data 1#$%'()*+,

86 assert "full_name" not in data 1#$%'()*+,

87 assert data["fullName"] == "Dana" 1#$%'()*+,

88 

89 

90@pytest.mark.parametrize("model", [PydanticUser, SQLModelUser]) 1abcidefgh

91def test_json_by_alias( 1abcidefgh

92 model: Union[type[PydanticUser], type[SQLModelUser]], 

93): 

94 user = model(fullName="Frank") 1-./:;=?@[

95 json_data = user.model_dump_json(by_alias=True) 1-./:;=?@[

96 assert ('"fullName":"Frank"' in json_data) or ('"fullName": "Frank"' in json_data) 1-./:;=?@[

97 assert "full_name" not in json_data 1-./:;=?@[

98 

99 

100class PydanticUserV2(BaseModel): 1abcidefgh

101 first_name: str = PField(validation_alias="firstName", serialization_alias="f_name") 1abcidefgh

102 

103 

104class SQLModelUserV2(SQLModel): 1abcidefgh

105 first_name: str = Field(validation_alias="firstName", serialization_alias="f_name") 1abcidefgh

106 

107 

108@pytest.mark.parametrize("model", [PydanticUserV2, SQLModelUserV2]) 1abcidefgh

109def test_create_with_validation_alias( 1abcidefgh

110 model: Union[type[PydanticUserV2], type[SQLModelUserV2]], 

111): 

112 user = model(firstName="John") 2UbVbWbXbYbZb0b1b2b

113 assert user.first_name == "John" 2UbVbWbXbYbZb0b1b2b

114 

115 

116@pytest.mark.parametrize("model", [PydanticUserV2, SQLModelUserV2]) 1abcidefgh

117def test_serialize_with_serialization_alias( 1abcidefgh

118 model: Union[type[PydanticUserV2], type[SQLModelUserV2]], 

119): 

120 user = model(firstName="Jane") 1TUVWXYZ01

121 data = user.model_dump(by_alias=True) 1TUVWXYZ01

122 assert "f_name" in data 1TUVWXYZ01

123 assert "firstName" not in data 1TUVWXYZ01

124 assert "first_name" not in data 1TUVWXYZ01

125 assert data["f_name"] == "Jane" 1TUVWXYZ01

126 

127 

128def test_schema_extra_validation_alias_sqlmodel_v2(): 1abcidefgh

129 class M(SQLModel): 2] ^ _ ` { | } ~ ab

130 f: str = Field(schema_extra={"validation_alias": "f_alias"}) 2] ^ _ ` { | } ~ ab

131 

132 m = M.model_validate({"f_alias": "asd"}) 2] ^ _ ` { | } ~ ab

133 assert m.f == "asd" 2] ^ _ ` { | } ~ ab

134 

135 

136def test_schema_extra_serialization_alias_sqlmodel_v2(): 1abcidefgh

137 class M(SQLModel): 1jklmnopqr

138 f: str = Field(schema_extra={"serialization_alias": "f_out"}) 1jklmnopqr

139 

140 m = M(f="x") 1jklmnopqr

141 data = m.model_dump(by_alias=True) 1jklmnopqr

142 assert "f_out" in data 1jklmnopqr

143 assert "f" not in data 1jklmnopqr

144 assert data["f_out"] == "x" 1jklmnopqr

145 

146 

147def test_alias_plus_validation_alias_prefers_validation_alias_sqlmodel_v2(): 1abcidefgh

148 class M(SQLModel): 2bbcbdbebfbgbhbibjb

149 first_name: str = Field(alias="fullName", validation_alias="v_name") 2bbcbdbebfbgbhbibjb

150 

151 m = M.model_validate({"fullName": "A", "v_name": "B"}) 2bbcbdbebfbgbhbibjb

152 assert m.first_name == "B" 2bbcbdbebfbgbhbibjb

153 

154 

155def test_alias_plus_serialization_alias_prefers_serialization_alias_sqlmodel_v2(): 1abcidefgh

156 class M(SQLModel): 1stuvwxyzA

157 first_name: str = Field(alias="fullName", serialization_alias="f_name") 1stuvwxyzA

158 

159 m = M(fullName="Z") 1stuvwxyzA

160 data = m.model_dump(by_alias=True) 1stuvwxyzA

161 assert "f_name" in data 1stuvwxyzA

162 assert "fullName" not in data 1stuvwxyzA

163 assert data["f_name"] == "Z" 1stuvwxyzA

164 

165 

166def test_alias_generator_works_sqlmodel_v2(): 1abcidefgh

167 class M(SQLModel): 1BCDEFGHIJ

168 model_config = {"alias_generator": lambda s: "gen_" + s} 1BCDEFGHIJ

169 f: str = Field() 1BCDEFGHIJ

170 

171 m = M.model_validate({"gen_f": "ok"}) 1BCDEFGHIJ

172 assert m.f == "ok" 1BCDEFGHIJ

173 data = m.model_dump(by_alias=True) 1BCDEFGHIJ

174 assert "gen_f" in data and data["gen_f"] == "ok" 1BCDEFGHIJ

175 

176 

177def test_alias_generator_with_explicit_alias_prefers_field_alias_sqlmodel_v2(): 1abcidefgh

178 class M(SQLModel): 1KLMNOPQRS

179 model_config = {"alias_generator": lambda s: "gen_" + s} 1KLMNOPQRS

180 f: str = Field(alias="custom") 1KLMNOPQRS

181 

182 m = M.model_validate({"custom": "ok"}) 1KLMNOPQRS

183 assert m.f == "ok" 1KLMNOPQRS

184 data = m.model_dump(by_alias=True) 1KLMNOPQRS

185 assert "custom" in data and "gen_f" not in data 1KLMNOPQRS