def test_sync(self):
     mitzi_cache = IdentityCache()
     atlas_cache = IdentityCache()
     mitzi_cache.update_ident(self.mitzi_ident)
     atlas_cache.update_ident(self.atlas_ident)
     mitzi_cache.sync(atlas_cache)
     self._assert_caches(mitzi_cache, atlas_cache)
 def test_decode(self):
     from ejtp.identity import Identity, IdentityCache
     cache = IdentityCache()
     cache[['testing']] = Identity('joe', ['rotate', 1], ['testing'])
     self.assertEqual(
         frame.encrypted.EncryptedFrame('r["testing"]\x00gpp').decode(
             cache), RawData('foo'))
    def test_deserialize(self):
        self.cache.update_ident(self.mitzi_ident)
        self.cache.update_ident(self.atlas_ident)

        serialization = self.cache.serialize()
        new_cache = IdentityCache()
        new_cache.deserialize(serialization)
        self._assert_caches(self.cache, new_cache)
Beispiel #4
0
    def get_ident(self, name):
        cache = IdentityCache()
        cache.update_idents(self.source.get_user(name))

        if len(cache.all()) > 0:
            status = 200
        else:
            status = 404

        payload = json.dumps(cache.serialize())
        if bytes != str:
            payload = bytes(payload, 'utf-8')
        return self.result(status, 'application/json', payload)
 def test_decode(self):
     from ejtp.identity import Identity, IdentityCache
     ident = Identity('joe', ['rotate', 1], ['testing'])
     cache = IdentityCache()
     cache[['testing']] = ident
     signature = ident.sign('foo')
     siglen = len(signature)
     signed_content = RawData('s["testing"]\x00') + (
         siglen // 256, siglen % 256) + signature + 'foo'
     self.assertEqual(
         frame.signed.SignedFrame(signed_content).decode(cache),
         RawData('foo'))
     self.assertRaises(
         ValueError,
         frame.signed.SignedFrame(
             's["testing"]\x00\x00\x07invalidfoo').decode, cache)
 def test_eq(self):
     self.thorough_equality(IdentRef(self.ident.key, self.cache))
     self.thorough_inequality(IdentRef("random key", self.cache))
     self.thorough_inequality(IdentRef(self.ident.key, IdentityCache()))
 def setUp(self):
     self.ident = mockup()
     self.cache = IdentityCache()
     self.cache.update_ident(self.ident)
     self.ref = IdentRef(self.ident.key, self.cache)
 def setUp(self):
     self.cache = IdentityCache()
     self.joe_ident = Identity('joe', ['rotate', 3], ['local', None, 'joe'])
     self.mitzi_ident = mockup('mitzi')
     self.atlas_ident = mockup('atlas')
     self.victor_ident = mockup('victor')