public void Bind_FieldTypeSupplied_UsesBinderToResolveType()
{
// Arrange
var @struct = new StructBuilder().Build();
var input =
@"struct User {
i32 Id
}";
var structNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.structDefinition());
this.binderProvider.GetBinder(structNode.field()[0].fieldType())
.Returns(this.typeBinder);
var type = Substitute.For <IFieldType>();
this.typeBinder.Bind <IFieldType>(
structNode.field()[0].fieldType(), Arg.Any <ISymbol>())
.Returns(type);
// Act
var field = this.binder.Bind <Field>(structNode.field()[0], @struct);
// Assert
Assert.Same(type, field.Type);
}
protected void AssertCompilerReturnsMessage(
string input,
CompilerMessageId messageId,
CompilerMessageType messageType,
string[] messageParameters)
{
// Arrange
var compiler = new ThriftCompiler();
var parserInput = ParserInput.FromString(input);
// Act
var result = compiler.Compile(parserInput.GetStream());
// Assert
var message = result.Messages.FirstOrDefault(
m => m.MessageType == messageType && m.MessageId == messageId);
Assert.True(message != null, $"No {messageType.ToString().ToLower()} messages were returned from the compiler");
if (parserInput.LineNumber != null)
{
Assert.Equal(parserInput.LineNumber, message.LineNumber);
Assert.Equal(parserInput.StartPosition, message.StartPosition);
Assert.Equal(parserInput.EndPosition, message.EndPosition);
}
if (messageParameters?.Length > 0)
{
var expectedMessage = string.Format(
CompilerMessages.Get(messageId), messageParameters);
Assert.Equal(expectedMessage, message.Message);
}
}
protected Exception CreateExceptionFromInput(string input)
{
var node = ParserInput
.FromString(input)
.ParseInput(parser => parser.exceptionDefinition());
return(new ExceptionBuilder()
.SetNode(node)
.SetBinderProvider(this.BinderProvider)
.Build());
}
protected Struct CreateStructFromInput(string input)
{
var structNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.structDefinition());
return(new StructBuilder()
.SetNode(structNode)
.SetBinderProvider(this.BinderProvider)
.Build());
}
protected Union CreateUnionFromInput(string input)
{
var structNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.unionDefinition());
return(new UnionBuilder()
.SetNode(structNode)
.SetBinderProvider(this.BinderProvider)
.Build());
}
protected Document CreateDocumentFromInput(string input)
{
var documentNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.document());
return(new DocumentBuilder()
.SetNode(documentNode)
.SetBinderProvider(this.BinderProvider)
.Build());
}
protected Enum CreateEnumFromInput(string input)
{
var enumNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.enumDefinition());
return(new EnumBuilder()
.SetNode(enumNode)
.SetBinderProvider(this.BinderProvider)
.Build());
}
public void TypeNotABaseType_ThrowsException()
{
// Arrange
var node = ParserInput
.FromString("UserType")
.ParseInput(parser => parser.baseType());
var parent = Substitute.For <IField>();
// Act / Assert
Assert.Throws <InvalidOperationException>(() => BaseType.Resolve(node, parent));
}
public void Bind_UnknownType_ThrowsException()
{
// Arrange
var field = new FieldBuilder().Build();
var node = ParserInput
.FromString("12345")
.ParseInput(parser => parser.fieldType());
// Act / Assert
Assert.Throws <ArgumentException>(() => this.binder.Bind <IFieldType>(node, field));
}
protected void AssertCompilerDoesNotReturnAnyMessages(string input)
{
// Arrange
var compiler = new ThriftCompiler();
var parserInput = ParserInput.FromString(input);
// Act
var result = compiler.Compile(parserInput.GetStream());
// Assert
Assert.Empty(result.Messages);
}
public static IEnumerable <object[]> GetBaseTypes()
{
var field = Substitute.For <IField>();
return(BaseType.Names.Select(name => new[]
{
BaseType.Resolve(
ParserInput
.FromString(name)
.ParseInput(parser => parser.baseType()),
field),
}));
}
public void SetsCorrectTypeForValue(string input, BaseType expectedType)
{
// Arrange
var binder = new ConstantExpressionBinder();
var node = ParserInput.FromString(input)
.ParseInput(parser => parser.constExpression());
var parent = Substitute.For <IConstant>();
// Act
var value = binder.Bind <IConstantExpression>(node, parent);
// Assert
Assert.Same(expectedType, value.Type);
}
public void SetsInvalidValueReasonCorrectly(string input, InvalidEnumValueReason expected)
{
// Arrange
var @enum = new EnumBuilder().Build();
var memberNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.enumMember());
// Act
var member = this.Binder.Bind <EnumMember>(memberNode, @enum);
// Assert
Assert.Equal(expected, member.InvalidValueReason);
}
public void RawValueNotProvided_Null()
{
// Arrange
var binder = new ConstantExpressionBinder();
var node = ParserInput.FromString(string.Empty)
.ParseInput(parser => parser.constExpression());
var parent = Substitute.For <IConstant>();
// Act
var value = binder.Bind <IConstantExpression>(node, parent);
// Assert
Assert.Null(value.RawValue);
}
public void Bind_IdentifierSupplied_SetsIdentifier()
{
// Arrange
var @struct = new StructBuilder().Build();
var fieldContext = ParserInput
.FromString("string Name")
.ParseInput(parser => parser.field());
// Act
var field = this.binder.Bind <Field>(fieldContext, @struct);
// Assert
Assert.Equal("Name", field.Name);
}
public void CanBindAllBaseTypes(string baseType)
{
// Arrange
var fieldTypeNode = ParserInput
.FromString(baseType)
.ParseInput(parser => parser.baseType());
// Act
var parent = Substitute.For <IField>();
var type = this.binder.Bind <BaseType>(fieldTypeNode, parent);
// Assert
Assert.Equal(baseType, type.Name);
}
public void RawValueProvided_SetsRawValue()
{
// Arrange
var binder = new ConstantExpressionBinder();
var node = ParserInput.FromString("100")
.ParseInput(parser => parser.constExpression());
var parent = Substitute.For <IConstant>();
// Act
var value = binder.Bind <IConstantExpression>(node, parent);
// Assert
Assert.Equal("100", value.RawValue);
}
public void Bind_FieldIdNotAnInteger_SetsFieldIdNull()
{
// Arrange
var @struct = new StructBuilder().Build();
var fieldContext = ParserInput
.FromString("abc: i32 Id")
.ParseInput(parser => parser.field());
// Act
var field = this.binder.Bind <Field>(fieldContext, @struct);
// Assert
Assert.Null(field.FieldId);
}
public void Bind_ExceptionNameNotSupplied_Null()
{
// Arrange
var document = new DocumentBuilder().Build();
var exceptionNode = ParserInput
.FromString("exception {}")
.ParseInput(parser => parser.exceptionDefinition());
// Act
var exception = this.binder.Bind <IException>(exceptionNode, document);
// Assert
Assert.Null(exception.Name);
}
public void Bind_FieldRequirednessOptional_SetsRequiredness()
{
// Arrange
var @struct = new StructBuilder().Build();
var fieldContext = ParserInput
.FromString("optional i32 Id")
.ParseInput(parser => parser.field());
// Act
var field = this.binder.Bind <Field>(fieldContext, @struct);
// Assert
Assert.Equal(FieldRequiredness.Optional, field.Requiredness);
}
public void Bind_StructNameSupplied_SetsName()
{
// Arrange
var document = new DocumentBuilder().Build();
var structContext = ParserInput
.FromString("union User {}")
.ParseInput(parser => parser.unionDefinition());
// Act
var union = this.binder.Bind <IUnion>(structContext, document);
// Assert
Assert.Equal("User", union.Name);
}
public void NameNotSupplied_Null()
{
// Arrange
var input = ParserInput
.FromString("const i32 = 100")
.ParseInput(parser => parser.constDefinition());
var parent = Substitute.For <IDocument>();
// Act
var result = this.constantBinder.Bind <IConstant>(input, parent);
// Assert
Assert.Null(result.Name);
}
protected override (IParseTree elementNode, ICollectionType collectionType) ParseInput(string input)
{
var node = ParserInput
.FromString(input)
.ParseInput(parser => parser.setType());
var setType = new SetTypeBuilder()
.SetNode(node)
.SetParent(this.Field)
.SetBinderProvider(this.BinderProvider)
.Build();
return(node.fieldType(), setType);
}
public void IndicatesWhenValueIsImplicit(string input, bool isImplicit)
{
// Arrange
var @enum = new EnumBuilder().Build();
var memberNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.enumMember());
// Act
var member = this.Binder.Bind <EnumMember>(memberNode, @enum);
// Assert
Assert.Equal(isImplicit, member.IsValueImplicit);
}
public void SetsNameCorrectly(string input, string expectedResult)
{
// Arrange
var @enum = new EnumBuilder().Build();
var memberNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.enumMember());
// Act
var member = this.Binder.Bind <EnumMember>(memberNode, @enum);
// Assert
Assert.Equal(expectedResult, member.Name);
}
public void Bind_FieldIdProvided_SetsFieldId()
{
// Arrange
var @struct = new StructBuilder().Build();
var fieldContext = ParserInput
.FromString("1: i32 Id")
.ParseInput(parser => parser.field());
// Act
var field = this.binder.Bind <Field>(fieldContext, @struct);
// Assert
Assert.Equal(1, field.FieldId);
}
public void Bind_StructNameNotSupplied_Null()
{
// Arrange
var document = new DocumentBuilder().Build();
var structContext = ParserInput
.FromString("struct {}")
.ParseInput(parser => parser.structDefinition());
// Act
var structDefinition = this.Binder.Bind <Struct>(structContext, document);
// Assert
Assert.Null(structDefinition.Name);
}
public void SetsNameCorrectly(string input, string name)
{
// Arrange
var document = new DocumentBuilder().Build();
var structNode = ParserInput
.FromString(input)
.ParseInput(parser => parser.enumDefinition());
// Act
var symbol = this.Binder.Bind <Enum>(structNode, document);
// Assert
Assert.Equal(name, symbol.Name);
}
public void NameSupplied_SetsName()
{
// Arrange
var input = ParserInput
.FromString("const i32 MaxPageSize = 100")
.ParseInput(parser => parser.constDefinition());
var parent = Substitute.For <IDocument>();
// Act
var result = this.constantBinder.Bind <IConstant>(input, parent);
// Assert
Assert.Equal("MaxPageSize", result.Name);
}
public void Bind_FieldRequirednessNotSupplied_UsesDefault()
{
// Arrange
var @struct = new StructBuilder().Build();
var fieldContext = ParserInput
.FromString("i32 Id")
.ParseInput(parser => parser.field());
// Act
var field = this.binder.Bind <Field>(fieldContext, @struct);
// Assert
Assert.Equal(FieldRequiredness.Default, field.Requiredness);
}
