public void InstanceAnnotationWriteTrackerIsCaseSensitive()
        {
            var    tracker = new InstanceAnnotationWriteTracker();
            string key     = "key";

            tracker.MarkAnnotationWritten(key.ToUpper());
            tracker.MarkAnnotationWritten(key.ToLower());

            tracker.IsAnnotationWritten(key.ToLower()).Should().BeTrue();
            tracker.IsAnnotationWritten(key.ToUpper()).Should().BeTrue();
        }
        public void InstanceAnnotationWriteTrackerIsCaseSensitive()
        {
            var tracker = new InstanceAnnotationWriteTracker();
            string key = "key";

            tracker.MarkAnnotationWritten(key.ToUpper());
            tracker.MarkAnnotationWritten(key.ToLower());

            tracker.IsAnnotationWritten(key.ToLower()).Should().BeTrue();
            tracker.IsAnnotationWritten(key.ToUpper()).Should().BeTrue();
        }
 public void InstanceAnnotationWriteTrackerTracksWrites()
 {
     var tracker = new InstanceAnnotationWriteTracker();
     tracker.IsAnnotationWritten("key").Should().BeFalse();
     tracker.MarkAnnotationWritten("key");
     tracker.IsAnnotationWritten("key").Should().BeTrue();
 }
        public void InstanceAnnotationWriteTrackerTracksWrites()
        {
            var tracker = new InstanceAnnotationWriteTracker();

            tracker.IsAnnotationWritten("key").Should().BeFalse();
            tracker.MarkAnnotationWritten("key");
            tracker.IsAnnotationWritten("key").Should().BeTrue();
        }
        public void InstanceAnnotationWriteTrackerTracksWrites()
        {
            var tracker = new InstanceAnnotationWriteTracker();

            Assert.False(tracker.IsAnnotationWritten("key"));
            tracker.MarkAnnotationWritten("key");
            Assert.True(tracker.IsAnnotationWritten("key"));
        }
        public void WriteInstanceAnnotationsShouldNotWriteAnnotationsThatHasAlreadyBeenWriten()
        {
            var primitive = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.primitive", new ODataPrimitiveValue(123)), /*target*/ null);
            var complex   = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.complex", new ODataComplexValue {
                Properties = new[] { new ODataProperty {
                                         Name = "p1", Value = 123
                                     } }, TypeName = "ns.complex1"
            }), /*target*/ null);
            var collection = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.collection", new ODataCollectionValue {
                Items = new[] { 123 }
            }), /*target*/ null);

            var instanceAnnotationWriteTracker = new InstanceAnnotationWriteTracker();

            instanceAnnotationWriteTracker.MarkAnnotationWritten("ns.primitive");
            instanceAnnotationWriteTracker.MarkAnnotationWritten("ns.collection");
            this.serializer.WriteInstanceAnnotations(new[] { primitive, complex, collection }, instanceAnnotationWriteTracker);
            this.ValidatePayload("<annotation term=\"ns.complex\" m:type=\"#ns.complex1\" xmlns:m=\"http://docs.oasis-open.org/odata/ns/metadata\" xmlns=\"http://docs.oasis-open.org/odata/ns/metadata\"><d:p1 m:type=\"Int32\" xmlns:d=\"http://docs.oasis-open.org/odata/ns/data\">123</d:p1></annotation>");

            instanceAnnotationWriteTracker.IsAnnotationWritten("ns.primitive").Should().BeTrue();
            instanceAnnotationWriteTracker.IsAnnotationWritten("ns.complex").Should().BeTrue();
            instanceAnnotationWriteTracker.IsAnnotationWritten("ns.collection").Should().BeTrue();
        }
        public void WriteInstanceAnnotationsShouldThrowWhenThereAreDuplicatedTermNames()
        {
            var primitive = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.term", new ODataPrimitiveValue(123)), /*target*/ null);
            var complex   = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.term", new ODataComplexValue {
                Properties = new[] { new ODataProperty {
                                         Name = "p1", Value = 123
                                     } }, TypeName = "ns.complex1"
            }), /*target*/ null);

            var instanceAnnotationWriteTracker = new InstanceAnnotationWriteTracker();

            instanceAnnotationWriteTracker.MarkAnnotationWritten("ns.term");
            Action test = () => this.serializer.WriteInstanceAnnotations(new[] { primitive, complex }, instanceAnnotationWriteTracker);

            test.ShouldThrow <ODataException>().WithMessage(Strings.JsonLightInstanceAnnotationWriter_DuplicateAnnotationNameInCollection("ns.term"));
        }
        /// <summary>
        /// Writes a collection of instance annotations in ATOM format.
        /// </summary>
        /// <param name="instanceAnnotations">Instance annotation collection to write.</param>
        /// <param name="tracker">The tracker to track which instance annotations have been written.</param>
        internal void WriteInstanceAnnotations(IEnumerable<AtomInstanceAnnotation> instanceAnnotations, InstanceAnnotationWriteTracker tracker)
        {
            Debug.Assert(instanceAnnotations != null, "instanceAnnotations should not be null if we called this");
            Debug.Assert(tracker != null, "tracker should not be null if we called this");

            HashSet<string> instanceAnnotationNames = new HashSet<string>(StringComparer.Ordinal);
            foreach (var annotation in instanceAnnotations)
            {
                if (!instanceAnnotationNames.Add(annotation.TermName))
                {
                    throw new ODataException(ODataErrorStrings.JsonLightInstanceAnnotationWriter_DuplicateAnnotationNameInCollection(annotation.TermName));
                }

                if (!tracker.IsAnnotationWritten(annotation.TermName))
                {
                    this.WriteInstanceAnnotation(annotation);
                    tracker.MarkAnnotationWritten(annotation.TermName);
                }
            }
        }
예제 #9
0
        /// <summary>
        /// Writes a collection of instance annotations in ATOM format.
        /// </summary>
        /// <param name="instanceAnnotations">Instance annotation collection to write.</param>
        /// <param name="tracker">The tracker to track which instance annotations have been written.</param>
        internal void WriteInstanceAnnotations(IEnumerable <AtomInstanceAnnotation> instanceAnnotations, InstanceAnnotationWriteTracker tracker)
        {
            Debug.Assert(instanceAnnotations != null, "instanceAnnotations should not be null if we called this");
            Debug.Assert(tracker != null, "tracker should not be null if we called this");

            HashSet <string> instanceAnnotationNames = new HashSet <string>(StringComparer.Ordinal);

            foreach (var annotation in instanceAnnotations)
            {
                if (!instanceAnnotationNames.Add(annotation.TermName))
                {
                    throw new ODataException(ODataErrorStrings.JsonLightInstanceAnnotationWriter_DuplicateAnnotationNameInCollection(annotation.TermName));
                }

                if (!tracker.IsAnnotationWritten(annotation.TermName))
                {
                    this.WriteInstanceAnnotation(annotation);
                    tracker.MarkAnnotationWritten(annotation.TermName);
                }
            }
        }
        public void WriteInstanceAnnotationsShouldNotWriteAnnotationsThatHasAlreadyBeenWriten()
        {
            var primitive = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.primitive", new ODataPrimitiveValue(123)), /*target*/ null);
            var complex = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.complex", new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "p1", Value = 123 } }, TypeName = "ns.complex1" }), /*target*/ null);
            var collection = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.collection", new ODataCollectionValue { Items = new[] { 123 } }), /*target*/ null);

            var instanceAnnotationWriteTracker = new InstanceAnnotationWriteTracker();
            instanceAnnotationWriteTracker.MarkAnnotationWritten("ns.primitive");
            instanceAnnotationWriteTracker.MarkAnnotationWritten("ns.collection");
            this.serializer.WriteInstanceAnnotations(new[] { primitive, complex, collection }, instanceAnnotationWriteTracker);
            this.ValidatePayload("<annotation term=\"ns.complex\" m:type=\"#ns.complex1\" xmlns:m=\"http://docs.oasis-open.org/odata/ns/metadata\" xmlns=\"http://docs.oasis-open.org/odata/ns/metadata\"><d:p1 m:type=\"Int32\" xmlns:d=\"http://docs.oasis-open.org/odata/ns/data\">123</d:p1></annotation>");

            instanceAnnotationWriteTracker.IsAnnotationWritten("ns.primitive").Should().BeTrue();
            instanceAnnotationWriteTracker.IsAnnotationWritten("ns.complex").Should().BeTrue();
            instanceAnnotationWriteTracker.IsAnnotationWritten("ns.collection").Should().BeTrue();
        }
        public void WriteInstanceAnnotationsShouldThrowWhenThereAreDuplicatedTermNames()
        {
            var primitive = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.term", new ODataPrimitiveValue(123)), /*target*/ null);
            var complex = AtomInstanceAnnotation.CreateFrom(new ODataInstanceAnnotation("ns.term", new ODataComplexValue { Properties = new[] { new ODataProperty { Name = "p1", Value = 123 } }, TypeName = "ns.complex1" }), /*target*/ null);

            var instanceAnnotationWriteTracker = new InstanceAnnotationWriteTracker();
            instanceAnnotationWriteTracker.MarkAnnotationWritten("ns.term");
            Action test = () => this.serializer.WriteInstanceAnnotations(new[] { primitive, complex }, instanceAnnotationWriteTracker);
            test.ShouldThrow<ODataException>().WithMessage(Strings.JsonLightInstanceAnnotationWriter_DuplicateAnnotationNameInCollection("ns.term"));
        }