def test_classSecurity(self):
     """
     Test for class-level security of serialization.
     """
     taster = jelly.SecurityOptions()
     taster.allowInstancesOf(A, B)
     a = A()
     b = B()
     c = C()
     # add a little complexity to the data
     a.b = b
     a.c = c
     # and a backreference
     a.x = b
     b.c = c
     # first, a friendly insecure serialization
     friendly = jelly.jelly(a, taster)
     x = jelly.unjelly(friendly, taster)
     self.assertIsInstance(x.c, jelly.Unpersistable)
     # now, a malicious one
     mean = jelly.jelly(a)
     self.assertRaises(jelly.InsecureJelly, jelly.unjelly, mean, taster)
     self.assertIdentical(x.x, x.b, "Identity mismatch")
     # test class serialization
     friendly = jelly.jelly(A, taster)
     x = jelly.unjelly(friendly, taster)
     self.assertIdentical(x, A, "A came back: %s" % x)

 def testClassSecurity(self):
     """
     test for class-level security of serialization
     """
     taster = jelly.SecurityOptions()
     taster.allowInstancesOf(A, B)
     a = A()
     b = B()
     c = C()
     # add a little complexity to the data
     a.b = b
     a.c = c
     # and a backreference
     a.x = b
     b.c = c
     # first, a friendly insecure serialization
     friendly = jelly.jelly(a, taster)
     x = jelly.unjelly(friendly, taster)
     assert isinstance(x.c, jelly.Unpersistable), "C came back: %s" % x.c.__class__
     # now, a malicious one
     mean = jelly.jelly(a)
     try:
         x = jelly.unjelly(mean, taster)
         assert 0, "x came back: %s" % x
     except jelly.InsecureJelly:
         # OK
         pass
     assert x.x is x.b, "Identity mismatch"

 def testLotsaTypes(self):
     """
     test for all types currently supported in jelly
     """
     a = A()
     jelly.unjelly(jelly.jelly(a))
     jelly.unjelly(jelly.jelly(a.amethod))
     items = [afunc, [1, 2, 3], not bool(1), bool(1), 'test', 20.3, (1,2,3), None, A, unittest, {'a':1}, A.amethod]
     for i in items:
         self.assertEquals(i, jelly.unjelly(jelly.jelly(i)))

 def testSerialize(self):
     text = N_("Something is really wrong.")
     self.cmsg = messages.Error(T_(text))
     self.mmsg = jelly.unjelly(jelly.jelly(self.cmsg))
     t = self.mmsg.translatables[0]
     self.assertEquals(t.format, "Something is really wrong.")
     self.assertEquals(self.mmsg.level, messages.ERROR)
     self.amsg = jelly.unjelly(jelly.jelly(self.mmsg))
     t = self.amsg.translatables[0]
     self.assertEquals(t.format, "Something is really wrong.")
     self.assertEquals(self.amsg.level, messages.ERROR)

 def test_oldSets(self):
     """
     Test jellying C{sets.Set}: it should serialize to the same thing as
     C{set} jelly, and be unjellied as C{set} if available.
     """
     inputList = [jelly._sets.Set([1, 2, 3])]
     inputJelly = jelly.jelly(inputList)
     self.assertEqual(inputJelly, jelly.jelly([set([1, 2, 3])]))
     output = jelly.unjelly(inputJelly)
     # Even if the class is different, it should coerce to the same list
     self.assertEqual(list(inputList[0]), list(output[0]))
     if set is jelly._sets.Set:
         self.assertIsInstance(output[0], jelly._sets.Set)
     else:
         self.assertIsInstance(output[0], set)

    def serialize(self, object, perspective=None, method=None, args=None, kw=None):
        """Jelly an object according to the remote security rules for this broker.
        """

        if isinstance(object, defer.Deferred):
            object.addCallbacks(
                self.serialize,
                lambda x: x,
                callbackKeywords={"perspective": perspective, "method": method, "args": args, "kw": kw},
            )
            return object

        # XXX This call is NOT REENTRANT and testing for reentrancy is just
        # crazy, so it likely won't be.  Don't ever write methods that call the
        # broker's serialize() method recursively (e.g. sending a method call
        # from within a getState (this causes concurrency problems anyway so
        # you really, really shouldn't do it))

        # self.jellier = _NetJellier(self)
        self.serializingPerspective = perspective
        self.jellyMethod = method
        self.jellyArgs = args
        self.jellyKw = kw
        try:
            return jelly(object, self.security, None, self)
        finally:
            self.serializingPerspective = None
            self.jellyMethod = None
            self.jellyArgs = None
            self.jellyKw = None

 def test_moreReferences(self):
     a = []
     t = (a,)
     a.append((t,))
     s = jelly.jelly(t)
     z = jelly.unjelly(s)
     self.assertIdentical(z[0][0][0], z)

    def testInvalidate(self):
        mcomp = planet.ManagerComponentState()
        mflow = planet.ManagerFlowState()
        mstate = planet.ManagerPlanetState()

        mflow.append('components', mcomp)
        mstate.append('flows', mflow)

        astate = jelly.unjelly(jelly.jelly(mstate))
        self.failUnless(isinstance(astate, planet.AdminPlanetState))

        aflow, = astate.get('flows')
        acomp, = aflow.get('components')

        invalidates = []

        def invalidate(obj):
            invalidates.append(obj)

        astate.addListener(self, invalidate=invalidate)
        aflow.addListener(self, invalidate=invalidate)
        acomp.addListener(self, invalidate=invalidate)

        self.assertEquals(invalidates, [])
        astate.invalidate()
        self.assertEquals(invalidates, [acomp, aflow, astate])

 def test_typeSecurity(self):
     """
     Test for type-level security of serialization.
     """
     taster = jelly.SecurityOptions()
     dct = jelly.jelly({})
     self.assertRaises(jelly.InsecureJelly, jelly.unjelly, dct, taster)

    def testPersistentStorage(self):
        perst = [{}, 1]
        def persistentStore(obj, jel, perst = perst):
            perst[1] = perst[1] + 1
            perst[0][perst[1]] = obj
            return str(perst[1])

        def persistentLoad(pidstr, unj, perst = perst):
            pid = int(pidstr)
            return perst[0][pid]

        a = SimpleJellyTest(1, 2)
        b = SimpleJellyTest(3, 4)
        c = SimpleJellyTest(5, 6)

        a.b = b
        a.c = c
        c.b = b

        jel = jelly.jelly(a, persistentStore = persistentStore)
        x = jelly.unjelly(jel, persistentLoad = persistentLoad)

        assert x.b is x.c.b, "Identity failure."
        # assert len(perst) == 3, "persistentStore should only be called 3 times."
        assert perst[0], "persistentStore was not called."
        assert x.b is a.b, "Persistent storage identity failure."

    def test_persistentStorage(self):
        perst = [{}, 1]

        def persistentStore(obj, jel, perst=perst):
            perst[1] = perst[1] + 1
            perst[0][perst[1]] = obj
            return str(perst[1])

        def persistentLoad(pidstr, unj, perst=perst):
            pid = int(pidstr)
            return perst[0][pid]

        a = SimpleJellyTest(1, 2)
        b = SimpleJellyTest(3, 4)
        c = SimpleJellyTest(5, 6)

        a.b = b
        a.c = c
        c.b = b

        jel = jelly.jelly(a, persistentStore=persistentStore)
        x = jelly.unjelly(jel, persistentLoad=persistentLoad)

        self.assertIdentical(x.b, x.c.b)
        self.failUnless(perst[0], "persistentStore was not called.")
        self.assertIdentical(x.b, a.b, "Persistent storage identity failure.")

    def save(self, statefile=None):
        """Save state as a pickled jelly to a file on disk."""
        if not statefile:
            if not self._statefile:
                raise MissingState("Could not find a state file to load.")
            statefile = self._statefile
        logging.debug("Saving state to: \t'%s'" % statefile)

        fh = None
        err = ''

        try:
            fh = open(statefile, 'w')
        except MissingState as error:
            err += error.message
        except (IOError, OSError) as error:
            err += "Error writing state file to '%s': %s" % (statefile, error)
        else:
            try:
                pickle.dump(jelly.jelly(self), fh)
            except AttributeError as error:
                logging.debug("Tried jellying an unjelliable object: %s"
                              % error.message)

        if fh is not None:
            fh.flush()
            fh.close()

 def test_methodSelfIdentity(self):
     a = A()
     b = B()
     a.bmethod = b.bmethod
     b.a = a
     im_ = jelly.unjelly(jelly.jelly(b)).a.bmethod
     self.assertEqual(im_.im_class, im_.im_self.__class__)

 def test_twiceUnjelliedFailureCheck(self):
     """
     The object which results from jellying a L{CopyableFailure}, unjellying
     the result, creating a new L{CopyableFailure} from the result of that,
     jellying it, and finally unjellying the result of that has a check
     method which behaves the same way as the original L{CopyableFailure}'s
     check method.
     """
     original = pb.CopyableFailure(ZeroDivisionError())
     self.assertIdentical(original.check(ZeroDivisionError), ZeroDivisionError)
     self.assertIdentical(original.check(ArithmeticError), ArithmeticError)
     copiedOnce = jelly.unjelly(jelly.jelly(original, invoker=DummyInvoker()))
     derivative = pb.CopyableFailure(copiedOnce)
     copiedTwice = jelly.unjelly(jelly.jelly(derivative, invoker=DummyInvoker()))
     self.assertIdentical(copiedTwice.check(ZeroDivisionError), ZeroDivisionError)
     self.assertIdentical(copiedTwice.check(ArithmeticError), ArithmeticError)

 def test_stressReferences(self):
     reref = []
     toplevelTuple = ({'list': reref}, reref)
     reref.append(toplevelTuple)
     s = jelly.jelly(toplevelTuple)
     z = jelly.unjelly(s)
     self.assertIs(z[0]['list'], z[1])
     self.assertIs(z[0]['list'][0], z)

 def test_typeOldStyle(self):
     """
     Test that an old style class type can be jellied and unjellied
     to the original type.
     """
     t = [C]
     r = jelly.unjelly(jelly.jelly(t))
     self.assertEquals(t, r)

 def test_dateTime(self):
     dtn = datetime.datetime.now()
     dtd = datetime.datetime.now() - dtn
     input = [dtn, dtd]
     c = jelly.jelly(input)
     output = jelly.unjelly(c)
     self.assertEqual(input, output)
     self.assertNotIdentical(input, output)

 def test_stressReferences(self):
     reref = []
     toplevelTuple = ({"list": reref}, reref)
     reref.append(toplevelTuple)
     s = jelly.jelly(toplevelTuple)
     z = jelly.unjelly(s)
     self.assertIdentical(z[0]["list"], z[1])
     self.assertIdentical(z[0]["list"][0], z)

 def test_typeBuiltin(self):
     """
     Test that a builtin type can be jellied and unjellied to the original
     type.
     """
     t = [str]
     r = jelly.unjelly(jelly.jelly(t))
     self.assertEqual(t, r)

 def test_typeNewStyle(self):
     """
     Test that a new style class type can be jellied and unjellied
     to the original type.
     """
     t = [D]
     r = jelly.unjelly(jelly.jelly(t))
     self.assertEqual(t, r)