public async Task CanSerializeAndDeserializeAClaim()
        {
            var claim = new Claim(Constants.ClaimTypes.Subject, "alice");

            var serializer = new JsonPropertySerializer(new MockScopeRepository(), new MockClientRepository());
            var json = await serializer.Serialize(claim);
            var deserializedClaim = await serializer.Deserialize<Claim>(json);

            Assert.AreEqual(Constants.ClaimTypes.Subject, deserializedClaim.Type);
            Assert.AreEqual(claim.Value, deserializedClaim.Value);
        }
        public async Task CanSerializeAndDeserializeAClaim()
        {
            var claim = new Claim(Constants.ClaimTypes.Subject, "alice");

            var serializer = new JsonPropertySerializer(new MockScopeRepository(), new MockClientRepository());
            var json       = await serializer.Serialize(claim);

            var deserializedClaim = await serializer.Deserialize <Claim>(json);

            Assert.AreEqual(Constants.ClaimTypes.Subject, deserializedClaim.Type);
            Assert.AreEqual(claim.Value, deserializedClaim.Value);
        }
示例#3
0
        public MessagePublisher(Lazy <IEventStoreConnection> lazyConnection, string streamName, IMessageSerializer serializer,
                                Func <TMessage, Dictionary <string, string> > propertyProvider)
        {
            _propertySerializer = new JsonPropertySerializer();
            _lazyConnection     = lazyConnection;
            _streamName         = streamName;
            _serializer         = serializer;
            _propertyProvider   = propertyProvider;
            _setProperties      = propertyProvider != null;

            _isJsonSerializer = _serializer.GetType().FullName.ToUpperInvariant().Contains("JSON");
        }
        public void TestStringSerializeProperties()
        {
            JsonPropertySerializer serializer = new JsonPropertySerializer(new PropertySchemaFactory());
            StringSchema           schema     = new StringSchema {
                MaxLength = 100, MinLength = 1, DefaultValue = "hello"
            };
            PropertyElement element = serializer.Serialize("hello", schema.Wrap());

            Assert.IsNotNull(element);
            Assert.AreEqual(typeof(StringSchema).FullName, element.Schema.SchemaType);
            Assert.AreEqual(SerializationTypeHint.String, element.SerializationHint);
            Assert.AreEqual("hello", element.Value);
        }
        public async Task CanSerializeAndDeserializeAClient()
        {
            var client = ObjectMother.CreateClientDocument("123");

            var clientRepo = new MockClientRepository();
            clientRepo.List.Add(client);

            var serializer = new JsonPropertySerializer(new MockScopeRepository(), clientRepo);
            var json = await serializer.Serialize(client);
            var deserializedClient = await serializer.Deserialize<Entities.ClientDocument>(json);
            
            deserializedClient.ShouldBeEquivalentTo(client);
        }
        public async Task CanSerializeAndDeserializeAScope()
        {
            var s1 = ObjectMother.CreateScopeDocument("email");
            var s2 = ObjectMother.CreateScopeDocument("read");

            var scopeRepo = new MockScopeRepository();
            scopeRepo.List.Add(s1);
            scopeRepo.List.Add(s2);

            var serializer = new JsonPropertySerializer(scopeRepo, new MockClientRepository());
            var json = await serializer.Serialize(s1);
            var deserializedScope = await serializer.Deserialize<Entities.ScopeDocument>(json);

            deserializedScope.ShouldBeEquivalentTo(s1);
        }
        public async Task CanSerializeAndDeserializeAClient()
        {
            var client = ObjectMother.CreateClientDocument("123");

            var clientRepo = new MockClientRepository();

            clientRepo.List.Add(client);

            var serializer = new JsonPropertySerializer(new MockScopeRepository(), clientRepo);
            var json       = await serializer.Serialize(client);

            var deserializedClient = await serializer.Deserialize <Entities.ClientDocument>(json);

            deserializedClient.ShouldBeEquivalentTo(client);
        }
示例#8
0
        public async Task CanSerializeAndDeserializeAScope()
        {
            var s1 = ObjectMother.CreateScopeDocument("email");
            var s2 = ObjectMother.CreateScopeDocument("read");

            var scopeRepo = new MockScopeRepository();

            scopeRepo.List.Add(s1);
            scopeRepo.List.Add(s2);

            var serializer = new JsonPropertySerializer(scopeRepo, new MockClientRepository());
            var json       = await serializer.Serialize(s1);

            var deserializedScope = await serializer.Deserialize <Entities.ScopeDocument>(json);

            deserializedScope.ShouldBeEquivalentTo(s1);
        }
        public async Task CanSerializeAndDeserializeAClaimPrincipal()
        {
            var claims = new Claim[]{
                new Claim(Constants.ClaimTypes.Subject, "alice"),
                new Claim(Constants.ClaimTypes.Scope, "read"),
                new Claim(Constants.ClaimTypes.Scope, "write"),
            };
            var ci = new ClaimsIdentity(claims, Constants.AuthenticationMethods.Password);
            var cp = new ClaimsPrincipal(ci);

            var serializer = new JsonPropertySerializer(new MockScopeRepository(), new MockClientRepository());
            var json = await serializer.Serialize(cp);
            var deserializedCp = await serializer.Deserialize<ClaimsPrincipal>(json);

            Assert.AreEqual(Constants.AuthenticationMethods.Password, deserializedCp.Identity.AuthenticationType);
            Assert.AreEqual(3, deserializedCp.Claims.Count());
            Assert.True(deserializedCp.HasClaim(Constants.ClaimTypes.Subject, "alice"));
            Assert.True(deserializedCp.HasClaim(Constants.ClaimTypes.Scope, "read"));
            Assert.True(deserializedCp.HasClaim(Constants.ClaimTypes.Scope, "write"));
        }
        public void TestStringDeSerializeProperties()
        {
            JsonPropertySerializer serializer = new JsonPropertySerializer(new PropertySchemaFactory());
            StringSchema           schema     = new StringSchema {
                MaxLength = 100, MinLength = 1, DefaultValue = "hello"
            };
            PropertyElement element = serializer.Serialize("hello", schema.Wrap());

            Assert.IsNotNull(element);
            Assert.AreEqual(typeof(StringSchema).FullName, element.Schema.SchemaType);
            Assert.AreEqual(SerializationTypeHint.String, element.SerializationHint);
            Assert.AreEqual("hello", element.Value);

            IValueSchema <object> vs = serializer.DeserializeSchema(element.Schema);

            Assert.IsNotNull(vs);
            IValueSchema <string> strSchema = vs.UnwrapRefType <string>();

            Assert.IsNotNull(strSchema);
        }
        public async Task CanSerializeAndDeserializeAClaimPrincipal()
        {
            var claims = new Claim[] {
                new Claim(Constants.ClaimTypes.Subject, "alice"),
                new Claim(Constants.ClaimTypes.Scope, "read"),
                new Claim(Constants.ClaimTypes.Scope, "write"),
            };
            var ci = new ClaimsIdentity(claims, Constants.AuthenticationMethods.Password);
            var cp = new ClaimsPrincipal(ci);

            var serializer = new JsonPropertySerializer(new MockScopeRepository(), new MockClientRepository());
            var json       = await serializer.Serialize(cp);

            var deserializedCp = await serializer.Deserialize <ClaimsPrincipal>(json);

            Assert.AreEqual(Constants.AuthenticationMethods.Password, deserializedCp.Identity.AuthenticationType);
            Assert.AreEqual(3, deserializedCp.Claims.Count());
            Assert.True(deserializedCp.HasClaim(Constants.ClaimTypes.Subject, "alice"));
            Assert.True(deserializedCp.HasClaim(Constants.ClaimTypes.Scope, "read"));
            Assert.True(deserializedCp.HasClaim(Constants.ClaimTypes.Scope, "write"));
        }
        public void TestStringDeSerializeProperties()
        {
            JsonPropertySerializer serializer = new JsonPropertySerializer(new PropertySchemaFactory());
            StringSchema schema = new StringSchema { MaxLength = 100, MinLength = 1, DefaultValue = "hello" };
            PropertyElement element = serializer.Serialize("hello", schema.Wrap());
            Assert.IsNotNull(element);
            Assert.AreEqual(typeof(StringSchema).FullName, element.Schema.SchemaType);
            Assert.AreEqual(SerializationTypeHint.String, element.SerializationHint);
            Assert.AreEqual("hello", element.Value);

            IValueSchema<object> vs = serializer.DeserializeSchema(element.Schema);
            Assert.IsNotNull(vs);
            IValueSchema<string> strSchema = vs.UnwrapRefType<string>();
            Assert.IsNotNull(strSchema);
        }
 public void TestStringSerializeProperties()
 {
     JsonPropertySerializer serializer=new JsonPropertySerializer(new PropertySchemaFactory());
     StringSchema schema=new StringSchema{MaxLength = 100,MinLength = 1, DefaultValue = "hello"};
     PropertyElement element = serializer.Serialize("hello", schema.Wrap());
     Assert.IsNotNull(element);
     Assert.AreEqual(typeof(StringSchema).FullName,element.Schema.SchemaType);
     Assert.AreEqual(SerializationTypeHint.String,element.SerializationHint);
     Assert.AreEqual("hello",element.Value);
 }