public void Static_Comparer_A_Value_Type()
{
var oldModel = new StructModel
{
Id = 1,
StructMember = new StructMember
{
Id = 1,
Value = "Old"
}
};
var newModel = new StructModel
{
Id = 1,
StructMember = new StructMember
{
Id = 1,
Value = "New"
}
};
var changes = Comparer.Compare(oldModel, newModel);
Assert.AreEqual(changes.Count(), 1);
Assert.IsNotNull(changes.Single(x => x.Name == "StructMember.Value" && (string)x.OldValue == "Old" && (string)x.NewValue == "New"));
}
/// <summary>
/// Interpreta los datos de una estructura
/// </summary>
protected void ParseStruct(SyntaxNode objNode, LanguageStructModel objParent, INamedTypeSymbol objSymbol)
{
StructModel objStruct = objParent.Items.CreateStruct(objParent);
// Inicializa los elementos
ParseNamedTypeSymbol(objStruct, objNode, objSymbol);
}
/// <summary>
/// Interpreta los datos de una estructura
/// </summary>
protected void ParseStruct(SyntaxNode node, LanguageStructModel parent, INamedTypeSymbol symbol)
{
StructModel structDoc = parent.Items.CreateStruct(parent);
// Inicializa los elementos
ParseNamedTypeSymbol(structDoc, node, symbol);
}
public void ParseEventStructHasRightType()
{
var ev = new StructModel("e", StructType.Event);
var parsed = FileModel.Parse(ev.Generate().NormalizeWhitespace().ToString(), FileModel.ParseOptions.DisallowMultipleStructs);
Assert.That(parsed, Is.Not.Null);
Assert.That(parsed.Structs[0].Type, Is.EqualTo(StructType.Event));
}
/// <summary>
/// Interpreta los datos de una estructura
/// </summary>
private void ParseStruct(SyntaxNode objNode, LanguageStructModel objParent)
{
StructModel objStruct = objParent.Items.CreateStruct(objParent);
INamedTypeSymbol objSymbol = objTreeSemantic.GetDeclaredSymbol(objNode as StructDeclarationSyntax);
// Inicializa los elementos
ParseNamedTypeSymbol(objStruct, objNode, objSymbol);
}
/// <summary>
/// Obtiene el MLNode de una estructura
/// </summary>
private void GetMLStruct(MLNode objMLRoot, DocumentFileModel objDocument)
{
StructModel objStruct = objDocument.LanguageStruct as StructModel;
if (objStruct != null)
{
AddTablesComplexParts(objMLRoot, objDocument);
}
}
public void RemoveAll(StructModel <int> provider)
{
try
{
_cacheMem.RemoveAll(provider.Item);
}
catch (Exception e)
{
ErrorLog.Error(e);
}
}
public void CanPopulateStruct()
{
var model = new StructModel();
var actual = Model.WriteLog <StructModel>(_output.WriteLine).Populate(model);
actual.Id.Should().NotBeEmpty();
actual.FirstName.Should().NotBeNullOrWhiteSpace();
actual.LastName.Should().NotBeNullOrWhiteSpace();
actual.Email.Should().NotBeNullOrWhiteSpace();
var expectedFirstName = EmailValueGenerator.SpecialCharacters.Replace(actual.FirstName !, string.Empty).ToLowerInvariant();
var expectedLastName = EmailValueGenerator.SpecialCharacters.Replace(actual.LastName !, string.Empty).ToLowerInvariant();
actual.Email.Should().StartWith(expectedFirstName + "." + expectedLastName + "@");
}
public void Should_invoke_response_negotiator_for_value_type_model()
{
// Given
var model = new StructModel();
var route = new FakeRoute(model);
var parameters = new DynamicDictionary();
var context = new NancyContext
{
Trace = new DefaultRequestTrace()
};
// When
var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result;
// Then
A.CallTo(() => this.responseNegotiator.NegotiateResponse(model, context)).MustHaveHappened();
}
internal FieldModel(MemberInfo memberInfo, Type fieldType, TypeDesc fieldTypeDesc)
{
_name = memberInfo.Name;
_fieldType = fieldType;
_fieldTypeDesc = fieldTypeDesc;
_memberInfo = memberInfo;
_checkShouldPersistMethodInfo = memberInfo.DeclaringType.GetMethod("ShouldSerialize" + memberInfo.Name, Array.Empty <Type>());
_checkShouldPersist = _checkShouldPersistMethodInfo != null;
FieldInfo specifiedField = memberInfo.DeclaringType.GetField(memberInfo.Name + "Specified");
if (specifiedField != null)
{
if (specifiedField.FieldType != typeof(bool))
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidSpecifiedType, specifiedField.Name, specifiedField.FieldType.FullName, typeof(bool).FullName));
}
_checkSpecified = specifiedField.IsInitOnly ? SpecifiedAccessor.ReadOnly : SpecifiedAccessor.ReadWrite;
_checkSpecifiedMemberInfo = specifiedField;
}
else
{
PropertyInfo specifiedProperty = memberInfo.DeclaringType.GetProperty(memberInfo.Name + "Specified");
if (specifiedProperty != null)
{
if (StructModel.CheckPropertyRead(specifiedProperty))
{
_checkSpecified = specifiedProperty.CanWrite ? SpecifiedAccessor.ReadWrite : SpecifiedAccessor.ReadOnly;
_checkSpecifiedMemberInfo = specifiedProperty;
}
if (_checkSpecified != SpecifiedAccessor.None && specifiedProperty.PropertyType != typeof(bool))
{
throw new InvalidOperationException(SR.Format(SR.XmlInvalidSpecifiedType, specifiedProperty.Name, specifiedProperty.PropertyType.FullName, typeof(bool).FullName));
}
}
}
if (memberInfo is PropertyInfo)
{
_readOnly = !((PropertyInfo)memberInfo).CanWrite;
_isProperty = true;
}
else if (memberInfo is FieldInfo)
{
_readOnly = ((FieldInfo)memberInfo).IsInitOnly;
}
}
public void PopulateReturnsValueWithoutModification()
{
var executeStrategy = Substitute.For <IExecuteStrategy>();
var expected = new StructModel
{
Email = Guid.NewGuid().ToString(),
FirstName = Guid.NewGuid().ToString(),
Id = Guid.NewGuid(),
LastName = Guid.NewGuid().ToString()
};
var sut = new StructTypeCreator();
var actual = sut.Populate(executeStrategy, expected);
actual.Should().BeEquivalentTo(expected);
}
internal TypeModel GetTypeModel(Type type, bool directReference)
{
TypeModel model;
if (_models.TryGetValue(type, out model))
{
return(model);
}
TypeDesc typeDesc = _typeScope.GetTypeDesc(type, null, directReference);
switch (typeDesc.Kind)
{
case TypeKind.Enum:
model = new EnumModel(type, typeDesc, this);
break;
case TypeKind.Primitive:
model = new PrimitiveModel(type, typeDesc, this);
break;
case TypeKind.Array:
case TypeKind.Collection:
case TypeKind.Enumerable:
model = new ArrayModel(type, typeDesc, this);
break;
case TypeKind.Root:
case TypeKind.Class:
case TypeKind.Struct:
model = new StructModel(type, typeDesc, this);
break;
default:
if (!typeDesc.IsSpecial)
{
throw new NotSupportedException(SR.Format(SR.XmlUnsupportedTypeKind, type.FullName));
}
model = new SpecialModel(type, typeDesc, this);
break;
}
_models.Add(type, model);
return(model);
}
public void IsIgnoredReturnsTrueWhenParameterMatchesStructPropertyWithNameMatch()
{
var configuration = Model.UsingDefaultConfiguration();
var value = new StructModel {
FirstName = Guid.NewGuid().ToString()
};
var model = new StructMatchingNameWrapper <StructModel>(value);
var propertyInfo =
typeof(StructMatchingNameWrapper <StructModel>).GetProperty(nameof(StructMatchingNameWrapper <StructModel>
.Value)) !;
var args = new object?[]
{
value
};
var sut = new DefaultPropertyResolver(CacheLevel.PerInstance);
var actual = sut.IsIgnored(configuration, model, propertyInfo, args);
actual.Should().BeTrue();
}
/// <summary>
/// Convierte una estructura
/// </summary>
private StructDocumentationModel ConvertStruct(StructDocumentationModel objParent, StructModel objItem)
{
StructDocumentationModel objStruct = Create(objParent, objItem, "Struct");
// Añade los parámetros de la clase compleja base
AddParametersBaseComplex(objStruct, objItem);
// Crea los elementos hijo
objStruct.Childs.AddRange(Convert(objStruct, objItem.Items));
// Devuelve la estructura
return(objStruct);
}
private bool InitializeStructMembers(StructMapping mapping, StructModel model, RecursionLimiter limiter)
{
if (mapping.IsFullyInitialized)
{
return(true);
}
if (model.TypeDesc.BaseTypeDesc != null)
{
StructMapping baseMapping = ImportStructLikeMapping((StructModel)_modelScope.GetTypeModel(model.Type.BaseType, false), limiter);
// check to see if the import of the baseMapping was deferred
int baseIndex = limiter.DeferredWorkItems.IndexOf(mapping.BaseMapping);
if (baseIndex < 0)
{
mapping.BaseMapping = baseMapping;
}
else
{
// the import of the baseMapping was deferred, make sure that the derived mappings is deferred as well
if (!limiter.DeferredWorkItems.Contains(mapping))
{
limiter.DeferredWorkItems.Add(new ImportStructWorkItem(model, mapping));
}
// make sure that baseMapping get processed before the derived
int top = limiter.DeferredWorkItems.Count - 1;
if (baseIndex < top)
{
ImportStructWorkItem baseMappingWorkItem = limiter.DeferredWorkItems[baseIndex];
limiter.DeferredWorkItems[baseIndex] = limiter.DeferredWorkItems[top];
limiter.DeferredWorkItems[top] = baseMappingWorkItem;
}
return(false);
}
}
ArrayList members = new ArrayList();
foreach (MemberInfo memberInfo in model.GetMemberInfos())
{
if (!(memberInfo is FieldInfo) && !(memberInfo is PropertyInfo))
{
continue;
}
SoapAttributes memberAttrs = GetAttributes(memberInfo);
if (memberAttrs.SoapIgnore)
{
continue;
}
FieldModel fieldModel = model.GetFieldModel(memberInfo);
if (fieldModel == null)
{
continue;
}
MemberMapping member = ImportFieldMapping(fieldModel, memberAttrs, mapping.Namespace, limiter);
if (member == null)
{
continue;
}
if (!member.TypeDesc.IsPrimitive && !member.TypeDesc.IsEnum && !member.TypeDesc.IsOptionalValue)
{
if (model.TypeDesc.IsValueType)
{
throw new NotSupportedException(SR.Format(SR.XmlRpcRefsInValueType, model.TypeDesc.FullName));
}
if (member.TypeDesc.IsValueType)
{
throw new NotSupportedException(SR.Format(SR.XmlRpcNestedValueType, member.TypeDesc.FullName));
}
}
if (mapping.BaseMapping != null)
{
if (mapping.BaseMapping.Declares(member, mapping.TypeName))
{
continue;
}
}
members.Add(member);
}
mapping.Members = (MemberMapping[])members.ToArray(typeof(MemberMapping));
if (mapping.BaseMapping == null)
{
mapping.BaseMapping = GetRootMapping();
}
IncludeTypes(model.Type, limiter);
return(true);
}
private StructMapping ImportStructLikeMapping(StructModel model, RecursionLimiter limiter)
{
if (model.TypeDesc.Kind == TypeKind.Root)
{
return(GetRootMapping());
}
SoapAttributes a = GetAttributes(model.Type);
string typeNs = _defaultNs;
if (a.SoapType != null && a.SoapType.Namespace != null)
{
typeNs = a.SoapType.Namespace;
}
string typeName = XsdTypeName(model.Type, a, model.TypeDesc.Name);
typeName = XmlConvert.EncodeLocalName(typeName);
StructMapping mapping = (StructMapping)GetTypeMapping(typeName, typeNs, model.TypeDesc);
if (mapping == null)
{
mapping = new StructMapping();
mapping.IsSoap = true;
mapping.TypeDesc = model.TypeDesc;
mapping.Namespace = typeNs;
mapping.TypeName = typeName;
if (a.SoapType != null)
{
mapping.IncludeInSchema = a.SoapType.IncludeInSchema;
}
_typeScope.AddTypeMapping(mapping);
_types.Add(typeName, typeNs, mapping);
if (limiter.IsExceededLimit)
{
limiter.DeferredWorkItems.Add(new ImportStructWorkItem(model, mapping));
return(mapping);
}
limiter.Depth++;
InitializeStructMembers(mapping, model, limiter);
while (limiter.DeferredWorkItems.Count > 0)
{
int index = limiter.DeferredWorkItems.Count - 1;
ImportStructWorkItem item = limiter.DeferredWorkItems[index];
if (InitializeStructMembers(item.Mapping, item.Model, limiter))
{
//
// if InitializeStructMembers returns true, then there were *no* changes to the DeferredWorkItems
//
#if DEBUG
// use exception in the place of Debug.Assert to avoid throwing asserts from a server process such as aspnet_ewp.exe
if (index != limiter.DeferredWorkItems.Count - 1)
{
throw new InvalidOperationException(SR.Format(SR.XmlInternalErrorDetails, "DeferredWorkItems.Count have changed"));
}
if (item != limiter.DeferredWorkItems[index])
{
throw new InvalidOperationException(SR.Format(SR.XmlInternalErrorDetails, "DeferredWorkItems.Top have changed"));
}
#endif
// Remove the last work item
limiter.DeferredWorkItems.RemoveAt(index);
}
}
limiter.Depth--;
}
return(mapping);
}
public void Should_invoke_response_negotiator_for_value_type_model()
{
// Given
var model = new StructModel();
var route = new FakeRoute(model);
var parameters = new DynamicDictionary();
var context = new NancyContext
{
Trace = new DefaultRequestTrace()
};
// When
var result = this.invoker.Invoke(route, new CancellationToken(), parameters, context).Result;
// Then
A.CallTo(() => this.responseNegotiator.NegotiateResponse(model, context)).MustHaveHappened();
}
/// <summary>
/// Convierte una estructura
/// </summary>
private StructDocumentationModel ConvertStruct(StructDocumentationModel parent, StructModel item)
{
StructDocumentationModel structDoc = Create(parent, item, "Struct");
// Añade los parámetros de la clase compleja base
AddParametersBaseComplex(structDoc, item);
// Crea los elementos hijo
structDoc.Childs.AddRange(Convert(structDoc, item.Items));
// Devuelve la estructura
return(structDoc);
}
