Revision 31d3b918

b/lib/cli.py
2778 2778
  else:
2779 2779
    raise errors.ProgrammerError("Invalid creation mode %s" % mode)
2780 2780

  
2781
  osparams_private = opts.osparams_private or serializer.PrivateDict()
2782
  osparams_secret = opts.osparams_private or serializer.PrivateDict()
2783

  
2781 2784
  op = opcodes.OpInstanceCreate(instance_name=instance,
2782 2785
                                disks=disks,
2783 2786
                                disk_template=opts.disk_template,
......
2794 2797
                                hvparams=hvparams,
2795 2798
                                beparams=opts.beparams,
2796 2799
                                osparams=opts.osparams,
2797
                                osparams_private=opts.osparams_private,
2798
                                osparams_secret=opts.osparams_secret,
2800
                                osparams_private=osparams_private,
2801
                                osparams_secret=osparams_secret,
2799 2802
                                mode=mode,
2800 2803
                                start=start,
2801 2804
                                os_type=os_type,
b/lib/serializer.py
244 244
    return self._item
245 245

  
246 246
  def __str__(self):
247
    return "<{._descr}>".format(self)
247
    return "<%s>" % self._descr
248 248

  
249 249
  def __repr__(self):
250
    return "Private(?, descr='{._descr}')".format(self)
250
    return "Private(?, descr=%r)".format(self._descr)
251 251

  
252 252
  # pylint: disable=W0212
253 253
  # If it doesn't access _item directly, the call will go through __getattr__
b/lib/utils/algo.py
95 95
  return list(dup)
96 96

  
97 97

  
98
#pylint: disable=W0142 (use of *-magic in argument list)
98
#pylint: disable=W0142
99
# (use of *-magic in argument list)
99 100
def GetRepeatedKeys(*dicts):
100 101
  """Return the set of keys defined multiple times in the given dicts.
101 102

  
b/test/py/ganeti.serializer_unittest.py
182 182
  def testLeak(self):
183 183
    pDict = serializer.PrivateDict()
184 184
    pDict["bar"] = "egg"
185
    self.assertNotIn("egg", str(pDict), "Value leaked in str(PrivateDict)")
186
    self.assertNotIn("egg", repr(pDict), "Value leaked in repr(PrivateDict)")
187
    self.assertNotIn("egg", "{0}".format(pDict),
185
    self.assertTrue("egg" not in str(pDict), "Value leaked in str(PrivateDict)")
186
    self.assertTrue("egg" not in repr(pDict), "Value leak in repr(PrivateDict)")
187
    self.assertTrue("egg" not in "{0}".format(pDict),
188 188
                     "Value leaked in PrivateDict.__format__")
189
    self.assertNotIn("egg", serializer.Dump(pDict),
189
    self.assertTrue("egg" not in serializer.Dump(pDict),
190 190
                     "Value leaked in serializer.Dump(PrivateDict)")
191 191

  
192 192
  def testProperAccess(self):
193 193
    pDict = serializer.PrivateDict()
194 194
    pDict["bar"] = "egg"
195 195

  
196
    self.assertIs("egg", pDict["bar"].Get(),
197
                  "Value not returned by Private.Get()")
198
    self.assertIs("egg", pDict.GetPrivate("bar"),
199
                  "Value not returned by Private.GetPrivate()")
200
    self.assertIs("egg", pDict.Unprivate()["bar"],
201
                  "Value not returned by PrivateDict.Unprivate()")
202
    self.assertIn(
203
      "egg",
204
      serializer.Dump(pDict,
205
                      private_encoder=serializer.EncodeWithPrivateFields)
206
    )
196
    self.assertTrue("egg" is pDict["bar"].Get(),
197
                    "Value not returned by Private.Get()")
198
    self.assertTrue("egg" is pDict.GetPrivate("bar"),
199
                    "Value not returned by Private.GetPrivate()")
200
    self.assertTrue("egg" is pDict.Unprivate()["bar"],
201
                    "Value not returned by PrivateDict.Unprivate()")
202

  
203
    json = serializer.Dump(pDict,
204
                           private_encoder=serializer.EncodeWithPrivateFields)
205
    self.assertTrue("egg" in json)
207 206

  
208 207
  def testDictGet(self):
209
    self.assertIs("tar", serializer.PrivateDict().GetPrivate("bar", "tar"),
210
                  "Private.GetPrivate() did not handle the default case")
208
    result = serializer.PrivateDict().GetPrivate("bar", "tar")
209
    self.assertTrue("tar" is result,
210
                    "Private.GetPrivate() did not handle the default case")
211 211

  
212 212
  def testZeronessPrivate(self):
213 213
    self.assertTrue(serializer.Private("foo"),

Also available in: Unified diff