public void GenerateModel_writes_errors_if_any_returned_from_model_generation()
{
var modelGenCache = new ModelGenErrorCache();
var mockPackage = new Mock<IEdmPackage>();
mockPackage.Setup(p => p.ModelGenErrorCache).Returns(modelGenCache);
PackageManager.Package = mockPackage.Object;
var mockHostContext = new Mock<ModelBuilderEngineHostContext>();
var mockModelBuilderSettings = CreateMockModelBuilderSettings();
var mockModelBuilderEngine = new Mock<ModelBuilderEngine> { CallBase = true };
var error = new EdmSchemaError("testError", 42, EdmSchemaErrorSeverity.Warning);
mockModelBuilderEngine
.Setup(m => m.GenerateModels(It.IsAny<string>(), It.IsAny<ModelBuilderSettings>(), It.IsAny<List<EdmSchemaError>>()))
.Callback(
(string storeModelNamespace, ModelBuilderSettings settings, List<EdmSchemaError> errors) => errors.Add(error))
.Returns(new DbModel(new DbProviderInfo("System.Data.SqlClient", "2008"), Mock.Of<DbProviderManifest>()));
mockModelBuilderEngine.Object.GenerateModel(mockModelBuilderSettings.Object, Mock.Of<IVsUtils>(), mockHostContext.Object);
mockModelBuilderEngine
.Verify(m => m.GenerateModels(
It.IsAny<string>(), It.IsAny<ModelBuilderSettings>(), It.IsAny<List<EdmSchemaError>>()), Times.Once());
mockHostContext.Verify(h => h.LogMessage(It.IsAny<string>()), Times.Exactly(3));
mockHostContext
.Verify(h => h.LogMessage(It.IsRegex(Resources.Engine_ModelGenErrors.Substring(1, 20))), Times.Once());
mockHostContext
.Verify(h => h.LogMessage(It.IsRegex(Resources.Engine_ModelGenException)), Times.Never());
Assert.Same(error, modelGenCache.GetErrors(mockModelBuilderSettings.Object.ModelPath).Single());
}
public void EdmSchemaError_stores_passed_arguments()
{
var schemaError = new EdmSchemaError("message", 100, EdmSchemaErrorSeverity.Error);
Assert.Equal("message", schemaError.Message);
Assert.Equal(100, schemaError.ErrorCode);
Assert.Equal(EdmSchemaErrorSeverity.Error, schemaError.Severity);
}
public void Can_add_get_error()
{
var mappingContext = new SimpleMappingContext(new EdmModel(DataSpace.SSpace), true);
Assert.Empty(mappingContext.Errors);
var error = new EdmSchemaError("bar", 0xF00, EdmSchemaErrorSeverity.Warning);
mappingContext.Errors.Add(error);
Assert.Same(error, mappingContext.Errors.Single());
}
public void GenerateModel_combines_store_model_and_mapping_errors()
{
var storeModelError = new EdmSchemaError("storeError", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List<EdmSchemaError> { storeModelError });
var entityType =
EntityType.Create(
"foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0],
new[] { errorMetadataProperty });
var storeModel = new EdmModel(DataSpace.SSpace);
storeModel.AddItem(entityType);
var mappingContext = new SimpleMappingContext(storeModel, true);
mappingContext.AddMapping(
storeModel.Containers.Single(),
EntityContainer.Create("C", DataSpace.CSpace, null, null, null));
mappingContext.Errors.Add(new EdmSchemaError("mappingError", 911, EdmSchemaErrorSeverity.Warning));
var mockModelGenerator = new Mock<ModelGenerator>(new ModelBuilderSettings(), "storeNamespace");
mockModelGenerator
.Setup(g => g.CreateStoreModel())
.Returns(() => storeModel);
mockModelGenerator
.Setup(g => g.CreateMappingContext(It.IsAny<EdmModel>()))
.Returns(() => mappingContext);
var errors = new List<EdmSchemaError>();
mockModelGenerator.Object.GenerateModel(errors);
Assert.Equal(new[] { storeModelError, mappingContext.Errors.Single() }, errors);
}
internal bool ValidateTypeConditions(bool validateAmbiguity, IList<EdmSchemaError> errors, string sourceLocation)
{
// Verify that all types can be produced
KeyToListMap<EntityType, LineInfo> unreachableEntityTypes;
KeyToListMap<EntityType, LineInfo> unreachableIsTypeOfs;
GetUnreachableTypes(validateAmbiguity, out unreachableEntityTypes, out unreachableIsTypeOfs);
var valid = true;
foreach (var unreachableEntityType in unreachableEntityTypes.KeyValuePairs)
{
var lineInfo = unreachableEntityType.Value.First();
var lines = StringUtil.ToCommaSeparatedString(unreachableEntityType.Value.Select(li => li.LineNumber));
var error = new EdmSchemaError(
Strings.Mapping_FunctionImport_UnreachableType(unreachableEntityType.Key.FullName, lines),
(int)StorageMappingErrorCode.MappingFunctionImportAmbiguousTypeConditions,
EdmSchemaErrorSeverity.Error,
sourceLocation,
lineInfo.LineNumber,
lineInfo.LinePosition);
errors.Add(error);
valid = false;
}
foreach (var unreachableIsTypeOf in unreachableIsTypeOfs.KeyValuePairs)
{
var lineInfo = unreachableIsTypeOf.Value.First();
var lines = StringUtil.ToCommaSeparatedString(unreachableIsTypeOf.Value.Select(li => li.LineNumber));
var isTypeOfDescription = StorageMslConstructs.IsTypeOf + unreachableIsTypeOf.Key.FullName
+ StorageMslConstructs.IsTypeOfTerminal;
var error = new EdmSchemaError(
Strings.Mapping_FunctionImport_UnreachableIsTypeOf(isTypeOfDescription, lines),
(int)StorageMappingErrorCode.MappingFunctionImportAmbiguousTypeConditions,
EdmSchemaErrorSeverity.Error,
sourceLocation,
lineInfo.LineNumber,
lineInfo.LinePosition);
errors.Add(error);
valid = false;
}
return valid;
}
// effects: Given a container, ensures that all entity/association
// sets in container on the C-side have been mapped
private static ErrorLog EnsureAllCSpaceContainerSetsAreMapped(
IEnumerable<Cell> cells,
EntityContainerMapping containerMapping)
{
var mappedExtents = new Set<EntitySetBase>();
string mslFileLocation = null;
EntityContainer container = null;
// Determine the container and name of the file while determining
// the set of mapped extents in the cells
foreach (var cell in cells)
{
mappedExtents.Add(cell.CQuery.Extent);
mslFileLocation = cell.CellLabel.SourceLocation;
// All cells are from the same container
container = cell.CQuery.Extent.EntityContainer;
}
Debug.Assert(container != null);
var missingExtents = new List<EntitySetBase>();
// Go through all the extents in the container and determine
// extents that are missing
foreach (var extent in container.BaseEntitySets)
{
if (mappedExtents.Contains(extent) == false
&& !(containerMapping.HasQueryViewForSetMap(extent.Name)))
{
var associationSet = extent as AssociationSet;
if (associationSet == null
|| !associationSet.ElementType.IsForeignKey)
{
missingExtents.Add(extent);
}
}
}
var errorLog = new ErrorLog();
// If any extent is not mapped, add an error
if (missingExtents.Count > 0)
{
var extentBuilder = new StringBuilder();
var isFirst = true;
foreach (var extent in missingExtents)
{
if (isFirst == false)
{
extentBuilder.Append(", ");
}
isFirst = false;
extentBuilder.Append(extent.Name);
}
var message = Strings.ViewGen_Missing_Set_Mapping(extentBuilder);
// Find the cell with smallest line number - so that we can
// point to the beginning of the file
var lowestLineNum = -1;
Cell smallestCell = null;
foreach (var cell in cells)
{
if (lowestLineNum == -1
|| cell.CellLabel.StartLineNumber < lowestLineNum)
{
smallestCell = cell;
lowestLineNum = cell.CellLabel.StartLineNumber;
}
}
Debug.Assert(smallestCell != null && lowestLineNum >= 0);
var edmSchemaError = new EdmSchemaError(
message, (int)ViewGenErrorCode.MissingExtentMapping,
EdmSchemaErrorSeverity.Error, containerMapping.SourceLocation, containerMapping.StartLineNumber,
containerMapping.StartLinePosition, null);
var record = new ErrorLog.Record(edmSchemaError);
errorLog.AddEntry(record);
}
return errorLog;
}
/// <summary>
///
/// </summary>
/// <param name="errorCode"></param>
/// <param name="severity"></param>
/// <param name="source"></param>
/// <param name="lineNumber"></param>
/// <param name="linePosition"></param>
/// <param name="message"></param>
private void AddError(
ErrorCode errorCode, EdmSchemaErrorSeverity severity, string sourceLocation, int lineNumber, int linePosition, object message)
{
EdmSchemaError error = null;
var messageString = message as string;
if (messageString != null)
{
error = new EdmSchemaError(messageString, (int)errorCode, severity, sourceLocation, lineNumber, linePosition);
}
else
{
var ex = message as Exception;
if (ex != null)
{
error = new EdmSchemaError(ex.Message, (int)errorCode, severity, sourceLocation, lineNumber, linePosition, ex);
}
else
{
error = new EdmSchemaError(message.ToString(), (int)errorCode, severity, sourceLocation, lineNumber, linePosition);
}
}
Schema.AddError(error);
}
internal void AddError(EdmSchemaError error)
{
_errors.Add(error);
}
private void Init(
ViewGenErrorCode errorCode, string message,
IEnumerable<Cell> sourceCells, string debugMessage)
{
m_sourceCells = new List<Cell>(sourceCells);
Debug.Assert(m_sourceCells.Count > 0, "Error record must have at least one cell");
// For certain foreign key messages, we may need the SSDL line numbers and file names
var label = m_sourceCells[0].CellLabel;
var sourceLocation = label.SourceLocation;
var lineNumber = label.StartLineNumber;
var columnNumber = label.StartLinePosition;
var userMessage = InternalToString(message, debugMessage, m_sourceCells, errorCode, false);
m_debugMessage = InternalToString(message, debugMessage, m_sourceCells, errorCode, true);
m_mappingError = new EdmSchemaError(
userMessage, (int)errorCode, EdmSchemaErrorSeverity.Error, sourceLocation,
lineNumber, columnNumber);
}
//There are cases when we want to create a ViewGen error that is not specific to any mapping fragment
//In this case, it is better to just create the EdmSchemaError directly and hold on to it.
internal Record(EdmSchemaError error)
{
m_debugMessage = error.ToString();
m_mappingError = error;
}
private bool TryConvertToPropertyMappings(
StructuralType structuralType,
RowType cTypeTvfElementType,
RowType sTypeTvfElementType,
EdmFunction functionImport,
FunctionImportStructuralTypeMappingKB functionImportKB,
IXmlLineInfo navLineInfo,
out List<PropertyMapping> propertyMappings)
{
propertyMappings = new List<PropertyMapping>();
// Gather and validate structuralType property mappings.
var errorFound = false;
foreach (EdmProperty property in TypeHelpers.GetAllStructuralMembers(structuralType))
{
// Only scalar property mappings are supported at the moment.
if (!Helper.IsScalarType(property.TypeUsage.EdmType))
{
var error = new EdmSchemaError(
Strings.Mapping_Invalid_CSide_ScalarProperty(property.Name),
(int)MappingErrorCode.InvalidTypeInScalarProperty,
EdmSchemaErrorSeverity.Error,
m_sourceLocation, navLineInfo.LineNumber, navLineInfo.LinePosition);
m_parsingErrors.Add(error);
errorFound = true;
continue;
}
string columnName = null;
IXmlLineInfo columnMappingLineInfo = null;
FunctionImportReturnTypeStructuralTypeColumnRenameMapping columnRenameMapping;
bool explicitPropertyMapping;
if (functionImportKB.ReturnTypeColumnsRenameMapping.TryGetValue(property.Name, out columnRenameMapping))
{
explicitPropertyMapping = true;
columnName = columnRenameMapping.GetRename(structuralType, out columnMappingLineInfo);
}
else
{
explicitPropertyMapping = false;
columnName = property.Name;
}
columnMappingLineInfo = columnMappingLineInfo != null && columnMappingLineInfo.HasLineInfo()
? columnMappingLineInfo
: navLineInfo;
EdmProperty column;
if (sTypeTvfElementType.Properties.TryGetValue(columnName, false, out column))
{
Debug.Assert(cTypeTvfElementType.Properties.Contains(columnName), "cTypeTvfElementType.Properties.Contains(columnName)");
var cTypeColumn = cTypeTvfElementType.Properties[columnName];
if (ValidateFunctionImportMappingResultTypeCompatibility(property.TypeUsage, cTypeColumn.TypeUsage))
{
propertyMappings.Add(new ScalarPropertyMapping(property, column));
}
else
{
var error = new EdmSchemaError(
GetInvalidMemberMappingErrorMessage(property, column),
(int)MappingErrorCode.IncompatibleMemberMapping,
EdmSchemaErrorSeverity.Error,
m_sourceLocation, columnMappingLineInfo.LineNumber, columnMappingLineInfo.LinePosition);
m_parsingErrors.Add(error);
errorFound = true;
}
}
else
{
if (explicitPropertyMapping)
{
AddToSchemaErrorsWithMemberInfo(
Strings.Mapping_InvalidContent_Column, columnName,
MappingErrorCode.InvalidStorageMember,
m_sourceLocation, columnMappingLineInfo, m_parsingErrors);
errorFound = true;
}
else
{
var error = new EdmSchemaError(
Strings.Mapping_FunctionImport_PropertyNotMapped(
property.Name, structuralType.FullName, functionImport.Identity),
(int)MappingErrorCode.MappingFunctionImportReturnTypePropertyNotMapped,
EdmSchemaErrorSeverity.Error,
m_sourceLocation, columnMappingLineInfo.LineNumber, columnMappingLineInfo.LinePosition);
m_parsingErrors.Add(error);
errorFound = true;
}
}
}
// Make sure that propertyMappings is in the order of properties of the structuredType.
// The rest of the code depends on it.
Debug.Assert(
errorFound ||
TypeHelpers.GetAllStructuralMembers(structuralType).Count == propertyMappings.Count &&
TypeHelpers.GetAllStructuralMembers(structuralType).Cast<EdmMember>().Zip(propertyMappings)
.All(ppm => ppm.Key.EdmEquals(ppm.Value.Property)),
"propertyMappings order does not correspond to the order of properties in the structuredType.");
return !errorFound;
}
private EFObject EdmSchemaError2EFObject(EdmSchemaError error, EFArtifact defaultArtifactForError)
{
EFArtifact a = null;
if (error.SchemaLocation != null)
{
a = _modelManager.GetArtifact(Utils.FileName2Uri(error.SchemaLocation));
}
if (a == null)
{
a = defaultArtifactForError;
}
return a.FindEFObjectForLineAndColumn(error.Line, error.Column);
}
private static ErrorInfo.Severity GetErrorInfoSeverity(EdmSchemaError error)
{
switch (error.Severity)
{
case EdmSchemaErrorSeverity.Error:
return ErrorInfo.Severity.ERROR;
case EdmSchemaErrorSeverity.Warning:
return ErrorInfo.Severity.WARNING;
default:
Debug.Fail("Unexpected value for EdmSchemaErrorSeverity");
return ErrorInfo.Severity.ERROR;
}
}
/// <summary>
/// Creates generated view object for the combination of the <paramref name="setMapping" />.Set and the
/// <paramref
/// name="type" />
/// .
/// This constructor is used for user-defined query views only.
/// </summary>
internal static bool TryParseUserSpecifiedView(
StorageSetMapping setMapping,
EntityTypeBase type,
string eSQL,
bool includeSubtypes,
StorageMappingItemCollection mappingItemCollection,
ConfigViewGenerator config,
/*out*/ IList<EdmSchemaError> errors,
out GeneratedView generatedView)
{
var failed = false;
DbQueryCommandTree commandTree;
DiscriminatorMap discriminatorMap;
Exception parserException;
if (
!TryParseView(
eSQL, true, setMapping.Set, mappingItemCollection, config, out commandTree, out discriminatorMap, out parserException))
{
var error = new EdmSchemaError(
Strings.Mapping_Invalid_QueryView2(setMapping.Set.Name, parserException.Message),
(int)StorageMappingErrorCode.InvalidQueryView, EdmSchemaErrorSeverity.Error,
setMapping.EntityContainerMapping.SourceLocation, setMapping.StartLineNumber, setMapping.StartLinePosition,
parserException);
errors.Add(error);
failed = true;
}
else
{
Debug.Assert(commandTree != null, "commandTree not set after parsing the view");
// Verify that all expressions appearing in the view are supported.
foreach (var error in ViewValidator.ValidateQueryView(commandTree, setMapping, type, includeSubtypes))
{
errors.Add(error);
failed = true;
}
// Verify that the result type of the query view is assignable to the element type of the entityset
var queryResultType = (commandTree.Query.ResultType.EdmType) as CollectionType;
if ((queryResultType == null)
|| (!setMapping.Set.ElementType.IsAssignableFrom(queryResultType.TypeUsage.EdmType)))
{
var error = new EdmSchemaError(
Strings.Mapping_Invalid_QueryView_Type(setMapping.Set.Name),
(int)StorageMappingErrorCode.InvalidQueryViewResultType, EdmSchemaErrorSeverity.Error,
setMapping.EntityContainerMapping.SourceLocation, setMapping.StartLineNumber, setMapping.StartLinePosition);
errors.Add(error);
failed = true;
}
}
if (!failed)
{
generatedView = new GeneratedView(setMapping.Set, type, commandTree, eSQL, discriminatorMap, mappingItemCollection, config);
return true;
}
else
{
generatedView = null;
return false;
}
}
public void CollectStoreModelErrors_returns_errors_from_function_return_rowtypes()
{
var edmSchemaError = new EdmSchemaError("msg", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List<EdmSchemaError> { edmSchemaError });
var rowType = RowType.Create(new EdmProperty[0], new[] { errorMetadataProperty });
var function =
EdmFunction.Create(
"foo",
"bar",
DataSpace.SSpace,
new EdmFunctionPayload
{
ReturnParameters =
new[]
{
FunctionParameter.Create(
"ReturnType",
rowType,
ParameterMode.ReturnValue)
}
},
null);
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(function);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Equal(1, schemaErrors.Count);
Assert.Same(edmSchemaError, schemaErrors.Single());
}
public void CollectStoreModelErrors_returns_errors_on_model_items()
{
var edmSchemaError = new EdmSchemaError("msg", 42, EdmSchemaErrorSeverity.Error);
var errorMetadataProperty =
MetadataProperty.Create(
MetadataItemHelper.SchemaErrorsMetadataPropertyName,
TypeUsage.CreateDefaultTypeUsage(
PrimitiveType.GetEdmPrimitiveType(PrimitiveTypeKind.String).GetCollectionType()),
new List<EdmSchemaError> { edmSchemaError });
var entityType =
EntityType.Create(
"foo", "bar", DataSpace.SSpace, new string[0], new EdmMember[0],
new[] { errorMetadataProperty });
var model = new EdmModel(DataSpace.SSpace);
model.AddItem(entityType);
var schemaErrors = ModelGenerator.CollectStoreModelErrors(model);
Assert.NotNull(schemaErrors);
Assert.Equal(1, schemaErrors.Count);
Assert.Same(edmSchemaError, schemaErrors.Single());
}