def test_ParseStructure_NoStructure_EmptyResult():
    tree = RpcDefinition("enum A { 1:i64 value; }").parse()

    visitor = StructureVisitor()
    structures = visitor.visit(tree)

    assert len(structures) == 0
def test_ParseStructure_StructWithoutMember_EmptyResult():
    tree = RpcDefinition(" struct A { } ").parse()

    visitor = StructureVisitor()
    structures = visitor.visit(tree)

    assert len(structures) == 0
def test_ParseStructure_MembersWithAmbiguousIds_RaisesRuntimeError():
    text = "struct A { 1:i32 a; 1:i64 b; }"
    tree = RpcDefinition(text).parse()

    visitor = StructureVisitor()

    with pytest.raises(RuntimeError):
        visitor.visit(tree)
def test_ParseStructure_TwoStructures_BothParsed():
    text = " struct A { 1:i16 B; } struct B { 1: i32 C; } "
    tree = RpcDefinition(text).parse()

    visitor = StructureVisitor()
    structures = visitor.visit(tree)

    assert len(structures) == 2
def test_ParseStructure_ListMember_Parsed():
    tree = RpcDefinition("struct A { 1:list<i64> value; }").parse()

    visitor = StructureVisitor()
    structures = visitor.visit(tree)

    assert len(structures) == 1
    assert len(structures[0].args) == 1
    assert isinstance(structures[0].args[0].valueType, ListType)
    assert isinstance(structures[0].args[0].valueType.valueType, RegularType)
    assert structures[0].args[0].valueType.valueType.name == "i64"
def test_ParseStructure_SingleMemberStructure_Parsed():
    tree = RpcDefinition("struct A { 1:i64 B; }").parse()

    visitor = StructureVisitor()
    structures = visitor.visit(tree)

    assert len(structures) == 1
    assert structures[0].name == "A"

    assert len(structures[0].args) == 1
    arg = structures[0].args[0]
    assert arg.name == "B"
    assert arg.uniqueId == 1
    assert arg.valueType.name == "i64"
def test_ParseStructure_MultipleMemberStructure_Parsed():
    text = "struct A { 1:i32 B; 2:binary C; }"
    tree = RpcDefinition(text).parse()

    visitor = StructureVisitor()
    structures = visitor.visit(tree)

    assert len(structures) == 1
    assert structures[0].name == "A"

    assert len(structures[0].args) == 2
    arg1 = structures[0].args[0]
    arg2 = structures[0].args[1]

    assert arg1.name == "B"
    assert arg1.uniqueId == 1
    assert arg1.valueType.name == "i32"

    assert arg2.name == "C"
    assert arg2.uniqueId == 2
    assert arg2.valueType.name == "binary"
def test_ParseServices_FullSample_Parsed():
    text = """
            
            include \"Types.thrift\"
            
            exception InvalidHandle
            {
                1:i32 c;
                2:binary d;
            }

            struct Parameters
            {
                1:i64 a;
                2:i16 b;
            }

            enum OperationMode
            {
                Sync = 4,
                Async,
                Both = 0x87
            }

            service Database
            {
                void Run(0xf:i32 a, 2:i64 b);
                void Stop(3:i64 c);
            }
            """
    tree = RpcDefinition(text).parse()

    visitor = IncludeVisitor()
    includes = visitor.visit(tree)
    assert len(includes) == 1

    visitor = ExceptionVisitor()
    exceptions = visitor.visit(tree)
    assert len(exceptions) == 1

    visitor = StructureVisitor()
    structures = visitor.visit(tree)
    assert len(structures) == 1

    visitor = EnumerationVisitor()
    enums = visitor.visit(tree)
    assert len(enums) == 1

    visitor = ServiceVisitor()
    services = visitor.visit(tree)
    assert len(services) == 1
def test_ValidationVisitor_ImportedEnumInStructure_NoErrorRaised():
    treeA = RpcDefinition("enum A { a = 0, b = 1 }").parse()
    treeB = RpcDefinition("struct B { 1:Types.A a; } ").parse()

    documentA = Document("Types", treeA)
    documentB = Document("test", treeB)
    documentB.includes = [IncludeDeclaration("Types", "Types.rpc")]

    visitor = EnumerationVisitor()
    documentA.enumerations = visitor.visit(treeA)
    visitor = StructureVisitor()
    documentB.structures = visitor.visit(treeB)

    visitor = ValidationVisitor([documentA, documentB], documentB.name)
    visitor.visit(documentB.parseTree)
def test_ValidationVisitor_ImportedTypeInStructure_NoErrorThrown():
    treeA = RpcDefinition("struct A { 1:i32 a; }").parse()
    treeB = RpcDefinition("struct B { 1:Types.A a; }").parse()

    documentA = Document("Types", treeA)
    documentB = Document("test", treeB)
    documentB.includes = [IncludeDeclaration("Types", "Types.rpc")]

    visitor = StructureVisitor()
    documentA.structures = visitor.visit(treeA)
    documentB.structures = visitor.visit(treeB)

    visitor = ValidationVisitor([documentA, documentB], documentB.name)
    visitor.visit(documentB.parseTree)
Esempio n. 11
0
def CreateModels(documents):
    for document in documents:
        visitor = IncludeVisitor()
        document.includes = visitor.visit(document.parseTree)

        visitor = ExceptionVisitor()
        document.exceptions = visitor.visit(document.parseTree)

        visitor = EnumerationVisitor()
        document.enumerations = visitor.visit(document.parseTree)

        visitor = StructureVisitor()
        document.structures = visitor.visit(document.parseTree)

        visitor = ServiceVisitor()
        document.services = visitor.visit(document.parseTree)

    for document in documents:
        visitor = ValidationVisitor(documents, document.name)
        visitor.visit(document.parseTree)
def test_ValidationVisitor_DifferentFunctionArgTypes_NoErrorRaised():
    tree = RpcDefinition("""
                         enum Event { foo = 0, bla = 1 }
                         struct Data { 1:Event value; }
                         service MainService {
                             void Foo(1:i64 a, 2:Event b, 3:Data c);
                         }
                         """).parse()

    document = Document("test", tree)

    visitor = EnumerationVisitor()
    document.enumerations = visitor.visit(document.parseTree)
    visitor = StructureVisitor()
    document.structures = visitor.visit(document.parseTree)
    visitor = ServiceVisitor()
    document.services = visitor.visit(document.parseTree)

    visitor = ValidationVisitor([document], document.name)
    visitor.visit(document.parseTree)
 def parseStructure(text: str):
     tree = RpcDefinition(text).parse()
     document = Document("test", tree)
     visitor = StructureVisitor()
     document.structures = visitor.visit(tree)
     return document