add more tests in benchmark

Author: valdergallo

graphql/execution/tests/test_benchmark.py

@@ -5,12 +5,48 @@
                      GraphQLSchema, Source, execute, parse)
 
 
-def test_big_list_of_ints(benchmark):
-    big_int_list = [x for x in range(5000)]
+# set global fixtures
+Container = namedtuple('Container', 'x y z o')
+big_int_list = [x for x in range(5000)]
+big_container_list = [Container(x=x, y=x, z=x, o=x) for x in range(5000)]
+
+ContainerType = GraphQLObjectType('Container',
+    fields={
+        'x': GraphQLField(GraphQLInt),
+        'y': GraphQLField(GraphQLInt),
+        'z': GraphQLField(GraphQLInt),
+        'o': GraphQLField(GraphQLInt),
+    })
+
+
+def resolve_all_containers(root, args, context, info):
+    return big_container_list
 
-    def resolve_all_ints(root, args, context, info):
-        return big_int_list
 
+def resolve_all_ints(root, args, context, info):
+    return big_int_list
+
+
+def test_big_list_of_ints_to_graphql_schema(benchmark):
+    @benchmark
+    def schema():
+        Query = GraphQLObjectType('Query', fields={
+            'allInts': GraphQLField(
+                GraphQLList(GraphQLInt),
+                resolver=resolve_all_ints
+            )
+        })
+        return GraphQLSchema(Query)
+
+
+def test_big_list_of_ints_to_graphql_ast(benchmark):
+    @benchmark
+    def ast():
+        source = Source('{ allInts }')
+        return parse(source)
+
+
+def test_big_list_of_ints_to_graphql_partial(benchmark):
     Query = GraphQLObjectType('Query', fields={
         'allInts': GraphQLField(
             GraphQLList(GraphQLInt),
@@ -20,43 +56,55 @@ def resolve_all_ints(root, args, context, info):
     hello_schema = GraphQLSchema(Query)
     source = Source('{ allInts }')
     ast = parse(source)
-    big_list_query = partial(execute, hello_schema, ast)
-    result = benchmark(big_list_query)
-    # result = big_list_query()
-    assert not result.errors
-    assert result.data == {'allInts': big_int_list}
 
+    @benchmark
+    def b():
+        return partial(execute, hello_schema, ast)
+
+def test_big_list_of_ints_to_graphql_total(benchmark):
+    @benchmark
+    def total():
+        Query = GraphQLObjectType('Query', fields={
+        'allInts': GraphQLField(
+            GraphQLList(GraphQLInt),
+                resolver=resolve_all_ints
+            )
+        })
+        hello_schema = GraphQLSchema(Query)
+        source = Source('{ allInts }')
+        ast = parse(source)
+        return partial(execute, hello_schema, ast)
 
 
-def test_big_list_of_ints_base(benchmark):
-    big_int_list = [x for x in range(5000)]
+def test_big_list_of_ints_base_serialize(benchmark):
     from ..executor import complete_leaf_value
-    # def convert_item(i):
-    #     return i
 
-    def convert_list():
-        r = []
+    @benchmark
+    def serialize():
         for i in big_int_list:
-            r.append(GraphQLInt.serialize(i))
-        return r
-    benchmark(convert_list)
+            GraphQLInt.serialize(i)
 
 
-def test_big_list_of_containers_with_one_field(benchmark):
-    Container = namedtuple('Container', 'x y z o')
+def test_total_big_list_of_containers_with_one_field_schema(benchmark):
+    @benchmark
+    def schema():
+        Query = GraphQLObjectType('Query', fields={
+            'allContainers': GraphQLField(
+                GraphQLList(ContainerType),
+                resolver=resolve_all_containers
+            )
+        })
+        return GraphQLSchema(Query)
 
-    ContainerType = GraphQLObjectType('Container', fields={
-        'x': GraphQLField(GraphQLInt),
-        'y': GraphQLField(GraphQLInt),
-        'z': GraphQLField(GraphQLInt),
-        'o': GraphQLField(GraphQLInt),
-    })
 
-    big_container_list = [Container(x=x, y=x, z=x, o=x) for x in range(5000)]
+def test_total_big_list_of_containers_with_one_field_parse(benchmark):
+    @benchmark
+    def ast():
+        source = Source('{ allContainers { x } }')
+        ast = parse(source)
 
-    def resolve_all_containers(root, args, context, info):
-        return big_container_list
 
+def test_total_big_list_of_containers_with_one_field_partial(benchmark):
     Query = GraphQLObjectType('Query', fields={
         'allContainers': GraphQLField(
             GraphQLList(ContainerType),
@@ -66,39 +114,55 @@ def resolve_all_containers(root, args, context, info):
     hello_schema = GraphQLSchema(Query)
     source = Source('{ allContainers { x } }')
     ast = parse(source)
-    big_list_query = partial(execute, hello_schema, ast)
-    result = benchmark(big_list_query)
-    # result = big_list_query()
-    assert not result.errors
-    assert result.data == {'allContainers': [{'x': c.x} for c in big_container_list]}
 
+    @benchmark
+    def b():
+        return partial(execute, hello_schema, ast)
 
-def test_big_list_of_containers_with_multiple_fields(benchmark):
-    Container = namedtuple('Container', 'x y z o')
 
-    ContainerType = GraphQLObjectType('Container', fields={
-        'x': GraphQLField(GraphQLInt),
-        'y': GraphQLField(GraphQLInt),
-        'z': GraphQLField(GraphQLInt),
-        'o': GraphQLField(GraphQLInt),
-    })
+def test_total_big_list_of_containers_with_one_field_total(benchmark):
+    @benchmark
+    def total():
+        Query = GraphQLObjectType('Query', fields={
+            'allContainers': GraphQLField(
+                GraphQLList(ContainerType),
+                resolver=resolve_all_containers
+            )
+        })
+        hello_schema = GraphQLSchema(Query)
+        source = Source('{ allContainers { x } }')
+        ast = parse(source)
+        result = partial(execute, hello_schema, ast)
 
-    big_container_list = [Container(x=x, y=x, z=x, o=x) for x in range(5000)]
-
-    def resolve_all_containers(root, args, context, info):
-        return big_container_list
 
+def test_total_big_list_of_containers_with_multiple_fields_partial(benchmark):
     Query = GraphQLObjectType('Query', fields={
         'allContainers': GraphQLField(
             GraphQLList(ContainerType),
             resolver=resolve_all_containers
         )
     })
+
     hello_schema = GraphQLSchema(Query)
     source = Source('{ allContainers { x, y, z } }')
     ast = parse(source)
-    big_list_query = partial(execute, hello_schema, ast)
-    result = benchmark(big_list_query)
-    # result = big_list_query()
-    assert not result.errors
-    assert result.data == {'allContainers': [{'x': c.x, 'y': c.y, 'z': c.z} for c in big_container_list]}
+
+    @benchmark
+    def b():
+        return partial(execute, hello_schema, ast)
+
+
+def test_total_big_list_of_containers_with_multiple_fields(benchmark):
+    @benchmark
+    def total():
+        Query = GraphQLObjectType('Query', fields={
+            'allContainers': GraphQLField(
+                GraphQLList(ContainerType),
+                resolver=resolve_all_containers
+            )
+        })
+
+        hello_schema = GraphQLSchema(Query)
+        source = Source('{ allContainers { x, y, z } }')
+        ast = parse(source)
+        result = partial(execute, hello_schema, ast)