Пример #1
0
        public void TestCreateMapperWithSerializePriority()
        {
            INodeDataMapperBuilder valueScalarBuilder = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapperBuilder valueListBuilder   = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapperBuilder nodeScalarBuilder  = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapperBuilder nodeListBuilder    = Substitute.For <INodeDataMapperBuilder>();

            builder.When(x => x.CreateValueScalarMapperBuilder()).DoNotCallBase();
            builder.When(x => x.CreateValueListMapperBuilder()).DoNotCallBase();
            builder.When(x => x.CreateNodeScalarMapperBuilder()).DoNotCallBase();
            builder.When(x => x.CreateNodeListMapperBuilder()).DoNotCallBase();

            builder.CreateValueScalarMapperBuilder().Returns(valueScalarBuilder);
            builder.CreateValueListMapperBuilder().Returns(valueListBuilder);
            builder.CreateNodeScalarMapperBuilder().Returns(nodeScalarBuilder);
            builder.CreateNodeListMapperBuilder().Returns(nodeListBuilder);

            INodeDataMapperBuilder[] expected = { nodeListBuilder, nodeScalarBuilder, valueListBuilder, valueScalarBuilder };

            builder.WhenForAnyArgs(x => x.BuildFromPrioritizedList(null)).DoNotCallBase();

            INodeDataMapper result = Substitute.For <INodeDataMapper>();

            builder.BuildFromPrioritizedList(expected).Returns(result);

            Assert.Same(result, builder.CreateMapperWithSerializePriority());

            builder.Received().BuildFromPrioritizedList(expected);
        }
Пример #2
0
        public void TestBuildFromPrioritizedList__Only()
        {
            INodeDataMapperBuilder builder1 = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapper        mapper   = Substitute.For <INodeDataMapper>();

            builder1.CanBuild.Returns(true);
            builder1.BuildMapper().Returns(mapper);

            Assert.Same(mapper, builder.BuildFromPrioritizedList(builder1));

            builder1.Received().BuildMapper();
        }
Пример #3
0
        public void TestBuildFromPrioritizedList__None()
        {
            INodeDataMapperBuilder builder1 = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapperBuilder builder2 = Substitute.For <INodeDataMapperBuilder>();

            builder1.CanBuild.Returns(false);
            builder2.CanBuild.Returns(false);

            Assert.Throws <NotImplementedException>(() => builder.BuildFromPrioritizedList(builder1, builder2));

            builder1.DidNotReceive().BuildMapper();
            builder2.DidNotReceive().BuildMapper();
        }
Пример #4
0
        public virtual INodeDataMapper BuildFromPrioritizedList(params INodeDataMapperBuilder[] list)
        {
            INodeDataMapperBuilder builder = list.FirstOrDefault(x => x.CanBuild);

            if (builder.IsNotNull())
            {
                return(builder.BuildMapper());
            }
            else
            {
                throw new NotImplementedException($"Cannot find a suitable way to load node data into field {fieldWrapper.MemberInfo.Name}");
            }
        }
Пример #5
0
        public void TestBuildFromPrioritizedList__Last()
        {
            INodeDataMapperBuilder builder1 = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapperBuilder builder2 = Substitute.For <INodeDataMapperBuilder>();
            INodeDataMapperBuilder builder3 = Substitute.For <INodeDataMapperBuilder>();

            builder1.CanBuild.Returns(false);
            builder2.CanBuild.Returns(false);
            builder3.CanBuild.Returns(true);

            INodeDataMapper mapper = Substitute.For <INodeDataMapper>();

            builder3.BuildMapper().Returns(mapper);

            Assert.Same(mapper, builder.BuildFromPrioritizedList(builder1, builder2, builder3));

            builder1.DidNotReceive().BuildMapper();
            builder2.DidNotReceive().BuildMapper();
            builder3.Received().BuildMapper();
        }