Revision d6f58310

b/test/ganeti.query_unittest.py
1128 1128

  
1129 1129
class TestQueryFilter(unittest.TestCase):
1130 1130
  def testRequestedNames(self):
1131
    innerfilter = [["=", "name", "x%s" % i] for i in range(4)]
1132

  
1133 1131
    for fielddefs in query.ALL_FIELD_LISTS:
1134
      assert "name" in fielddefs
1132
      if "id" in fielddefs:
1133
        namefield = "id"
1134
      else:
1135
        namefield = "name"
1136

  
1137
      assert namefield in fielddefs
1138

  
1139
      innerfilter = [["=", namefield, "x%s" % i] for i in range(4)]
1135 1140

  
1136 1141
      # No name field
1137
      q = query.Query(fielddefs, ["name"], qfilter=["=", "name", "abc"],
1142
      q = query.Query(fielddefs, [namefield], qfilter=["=", namefield, "abc"],
1138 1143
                      namefield=None)
1139 1144
      self.assertEqual(q.RequestedNames(), None)
1140 1145

  
1141 1146
      # No filter
1142
      q = query.Query(fielddefs, ["name"], qfilter=None, namefield="name")
1147
      q = query.Query(fielddefs, [namefield], qfilter=None, namefield=namefield)
1143 1148
      self.assertEqual(q.RequestedNames(), None)
1144 1149

  
1145 1150
      # Check empty query
1146
      q = query.Query(fielddefs, ["name"], qfilter=["|"], namefield="name")
1151
      q = query.Query(fielddefs, [namefield], qfilter=["|"],
1152
                      namefield=namefield)
1147 1153
      self.assertEqual(q.RequestedNames(), None)
1148 1154

  
1149 1155
      # Check order
1150
      q = query.Query(fielddefs, ["name"], qfilter=["|"] + innerfilter,
1151
                      namefield="name")
1156
      q = query.Query(fielddefs, [namefield], qfilter=["|"] + innerfilter,
1157
                      namefield=namefield)
1152 1158
      self.assertEqual(q.RequestedNames(), ["x0", "x1", "x2", "x3"])
1153 1159

  
1154 1160
      # Check reverse order
1155
      q = query.Query(fielddefs, ["name"],
1161
      q = query.Query(fielddefs, [namefield],
1156 1162
                      qfilter=["|"] + list(reversed(innerfilter)),
1157
                      namefield="name")
1163
                      namefield=namefield)
1158 1164
      self.assertEqual(q.RequestedNames(), ["x3", "x2", "x1", "x0"])
1159 1165

  
1160 1166
      # Duplicates
1161
      q = query.Query(fielddefs, ["name"],
1167
      q = query.Query(fielddefs, [namefield],
1162 1168
                      qfilter=["|"] + innerfilter + list(reversed(innerfilter)),
1163
                      namefield="name")
1169
                      namefield=namefield)
1164 1170
      self.assertEqual(q.RequestedNames(), ["x0", "x1", "x2", "x3"])
1165 1171

  
1166 1172
      # Unknown name field
1167
      self.assertRaises(AssertionError, query.Query, fielddefs, ["name"],
1173
      self.assertRaises(AssertionError, query.Query, fielddefs, [namefield],
1168 1174
                        namefield="_unknown_field_")
1169 1175

  
1170 1176
      # Filter with AND
1171
      q = query.Query(fielddefs, ["name"],
1172
                      qfilter=["|", ["=", "name", "foo"],
1173
                                    ["&", ["=", "name", ""]]],
1174
                      namefield="name")
1177
      q = query.Query(fielddefs, [namefield],
1178
                      qfilter=["|", ["=", namefield, "foo"],
1179
                                    ["&", ["=", namefield, ""]]],
1180
                      namefield=namefield)
1175 1181
      self.assertTrue(q.RequestedNames() is None)
1176 1182

  
1177 1183
      # Filter with NOT
1178
      q = query.Query(fielddefs, ["name"],
1179
                      qfilter=["|", ["=", "name", "foo"],
1180
                                    ["!", ["=", "name", ""]]],
1181
                      namefield="name")
1184
      q = query.Query(fielddefs, [namefield],
1185
                      qfilter=["|", ["=", namefield, "foo"],
1186
                                    ["!", ["=", namefield, ""]]],
1187
                      namefield=namefield)
1182 1188
      self.assertTrue(q.RequestedNames() is None)
1183 1189

  
1184 1190
      # Filter with only OR (names must be in correct order)
1185
      q = query.Query(fielddefs, ["name"],
1186
                      qfilter=["|", ["=", "name", "x17361"],
1187
                                    ["|", ["=", "name", "x22015"]],
1188
                                    ["|", ["|", ["=", "name", "x13193"]]],
1189
                                    ["=", "name", "x15215"]],
1190
                      namefield="name")
1191
      q = query.Query(fielddefs, [namefield],
1192
                      qfilter=["|", ["=", namefield, "x17361"],
1193
                                    ["|", ["=", namefield, "x22015"]],
1194
                                    ["|", ["|", ["=", namefield, "x13193"]]],
1195
                                    ["=", namefield, "x15215"]],
1196
                      namefield=namefield)
1191 1197
      self.assertEqual(q.RequestedNames(),
1192 1198
                       ["x17361", "x22015", "x13193", "x15215"])
1193 1199

  
1194 1200
  @staticmethod
1195
  def _GenNestedFilter(op, depth):
1196
    nested = ["=", "name", "value"]
1201
  def _GenNestedFilter(namefield, op, depth):
1202
    nested = ["=", namefield, "value"]
1197 1203
    for i in range(depth):
1198 1204
      nested = [op, nested]
1199 1205
    return nested
......
1201 1207
  def testCompileFilter(self):
1202 1208
    levels_max = query._FilterCompilerHelper._LEVELS_MAX
1203 1209

  
1204
    checks = [
1205
      [], ["="], ["=", "foo"], ["unknownop"], ["!"],
1206
      ["=", "_unknown_field", "value"],
1207
      self._GenNestedFilter("|", levels_max),
1208
      self._GenNestedFilter("|", levels_max * 3),
1209
      self._GenNestedFilter("!", levels_max),
1210
      ]
1211

  
1212 1210
    for fielddefs in query.ALL_FIELD_LISTS:
1211
      if "id" in fielddefs:
1212
        namefield = "id"
1213
      else:
1214
        namefield = "name"
1215

  
1216
      checks = [
1217
        [], ["="], ["=", "foo"], ["unknownop"], ["!"],
1218
        ["=", "_unknown_field", "value"],
1219
        self._GenNestedFilter(namefield, "|", levels_max),
1220
        self._GenNestedFilter(namefield, "|", levels_max * 3),
1221
        self._GenNestedFilter(namefield, "!", levels_max),
1222
        ]
1223

  
1213 1224
      for qfilter in checks:
1214 1225
        self.assertRaises(errors.ParameterError, query._CompileFilter,
1215 1226
                          fielddefs, None, qfilter)
1216 1227

  
1217 1228
      for op in ["|", "!"]:
1218
        qfilter = self._GenNestedFilter(op, levels_max - 1)
1229
        qfilter = self._GenNestedFilter(namefield, op, levels_max - 1)
1219 1230
        self.assertTrue(callable(query._CompileFilter(fielddefs, None,
1220 1231
                                                      qfilter)))
1221 1232

  

Also available in: Unified diff