public void Serialize_with_schemaNamespace_returns_false_if_error_in_model()
        {
            var model      = new EdmModel(DataSpace.SSpace);
            var mockWriter = new Mock <XmlWriter>();

            // add EntityType with no properties which will cause error
            var et = new EntityType("TestEntity", "TestNamespace", DataSpace.SSpace);

            model.AddItem(et);

            var validationErrors = new List <Validation.DataModelErrorEventArgs>();
            var serializer       = new SsdlSerializer();

            serializer.OnError += (_, e) => validationErrors.Add(e);
            Assert.False(serializer.Serialize(
                             model,
                             "MyNamespace",
                             ProviderRegistry.Sql2008_ProviderInfo.ProviderInvariantName,
                             ProviderRegistry.Sql2008_ProviderInfo.ProviderManifestToken,
                             mockWriter.Object,
                             false));
            Assert.Equal(1, validationErrors.Count());
            Assert.Equal(
                Strings.EdmModel_Validator_Semantic_KeyMissingOnEntityType("TestEntity"),
                validationErrors[0].ErrorMessage);
            mockWriter.Verify(m => m.WriteStartDocument(), Times.Never());
        }
        public void Serialize_without_schemaNamespace_returns_false_if_multiple_Containers()
        {
            var mockModel = new Mock <EdmModel>(DataSpace.SSpace, XmlConstants.SchemaVersionLatest);

            mockModel.Setup(m => m.Containers).Returns(
                new EntityContainer[] {
                new EntityContainer("Container1", DataSpace.SSpace),
                new EntityContainer("Container2", DataSpace.SSpace)
            });
            var mockWriter = new Mock <XmlWriter>();

            var validationErrors = new List <Validation.DataModelErrorEventArgs>();
            var serializer       = new SsdlSerializer();

            serializer.OnError += (_, e) => validationErrors.Add(e);
            Assert.False(serializer.Serialize(
                             mockModel.Object,
                             ProviderRegistry.Sql2008_ProviderInfo.ProviderInvariantName,
                             ProviderRegistry.Sql2008_ProviderInfo.ProviderManifestToken,
                             mockWriter.Object,
                             false));
            Assert.Equal(1, validationErrors.Count());
            Assert.Equal(Strings.Serializer_OneNamespaceAndOneContainer, validationErrors[0].ErrorMessage);
            mockWriter.Verify(m => m.WriteStartDocument(), Times.Never());
        }
        public void Validation_error_not_reported_for_types_marked_as_invalid()
        {
            var invalidAttribute =
                MetadataProperty.Create(
                    "EdmSchemaInvalid",
                    TypeUsage.CreateDefaultTypeUsage(PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String)),
                    true);

            var model = new EdmModel(DataSpace.SSpace);

            model.AddItem(
                EntityType.Create("E", "N", DataSpace.SSpace, new string[0], new EdmMember[0], new[] { invalidAttribute }));

            using (var writer = XmlWriter.Create(new StringBuilder()))
            {
                var ssdlSerializer = new SsdlSerializer();
                ssdlSerializer.OnError += (_, e) => { throw new Exception("Should not be invoked."); };

                Assert.True(ssdlSerializer.Serialize(model, "N", "invName", "42", writer));
            }
        }