def execute_graphql( schema: GraphQLSchema, test_data: CommonTestData, client: OrientDB, sample_parameters: Dict[str, Any], ) -> FrozenSet[Tuple[FrozenSet[Tuple[str, Any]], int]]: """Compile GraphQL query to MATCH, execute it against the test_db, and return the results.""" schema_based_type_equivalence_hints: Dict[ Union[GraphQLInterfaceType, GraphQLObjectType], GraphQLUnionType ] = {} if test_data.type_equivalence_hints: # For test convenience, we accept the type equivalence hints in string form. # Here, we convert them to the required GraphQL types. for key, value in six.iteritems(test_data.type_equivalence_hints): key_type = schema.get_type(key) value_type = schema.get_type(value) if ( key_type and value_type and ( isinstance(key_type, GraphQLInterfaceType) or isinstance(key_type, GraphQLObjectType) ) and isinstance(value_type, GraphQLUnionType) ): schema_based_type_equivalence_hints[key_type] = value_type else: raise AssertionError( "Expected key_type to be of type GraphQLInterfaceType or GraphQLObject Type, " "but received {}; and value_type to be of type GraphQLUnionType, but " "received {}.".format(type(key_type), type(value_type)) ) common_schema_info = CommonSchemaInfo(schema, schema_based_type_equivalence_hints) result = graphql_to_match(common_schema_info, test_data.graphql_input, sample_parameters) # We need to preprocess the results to be agnostic of the returned order. # For this we perform the following steps # - convert lists (returned from @fold scopes) to tuples to make them hashable # - convert each row dict to a frozenset of its items # - create a Counter (multi-set) of the row frozensets # - convert the multi-set to a frozenset of its items row_dicts = [row.oRecordData for row in client.command(result.query)] if len(row_dicts) == 0: raise AssertionError("Zero records returned. Trivial snapshot not allowed.") row_dicts_using_tuples = [ { column_name: convert_decimals_to_strings( tuple(value) if isinstance(value, list) else value ) for column_name, value in row.items() } for row in row_dicts ] row_frozensets = [frozenset(row_dict.items()) for row_dict in row_dicts_using_tuples] rows_multiset = Counter(row_frozensets) row_counters_frozenset = frozenset(rows_multiset.items()) return row_counters_frozenset
def graphql_ast_flatten_field(field: Field, fragments: Dict[str, FragmentDefinition], schema, root_schema: GraphQLSchema) -> List[str]: results = [] # is_list = isinstance(schema, GraphQLList) list_count = 0 while True: schema_changed = False if isinstance(schema, GraphQLNonNull): schema = schema.of_type schema_changed = True if isinstance(schema, GraphQLList): list_count += 1 schema = schema.of_type schema_changed = True if not schema_changed: break if getattr(field, 'selection_set', None) is not None: for sub_field in field.selection_set.selections: if isinstance(sub_field, FragmentSpread): sub_field = fragments[sub_field.name.value] sub_field_schema = schema else: sub_field_schema = graphql_ast_get_subfield( schema, sub_field.name.value) if type(sub_field_schema) == str: sub_field_schema = root_schema.get_type(sub_field_schema) sub_field_results = graphql_ast_flatten_field( sub_field, fragments, sub_field_schema, root_schema) if isinstance(field, FragmentDefinition): results += sub_field_results else: for result in sub_field_results: results.append( f"{change_case(field.name.value)}{'[*]' * list_count}.{result}" ) else: results.append(change_case(field.name.value)) return results