Пример #1
0
    def test_undouble(self):
        # Generate random lists of integers, plus add empty list
        testcases = [[random.randint(0, 10) for _ in range(random.randint(0, 50))] for _ in range(20)] + [[]]

        formatter = GraphQLResultFormatter()

        for testcase in testcases:
            self.assertEqual(sorted(list(set(testcase))), sorted(formatter._undouble(testcase)))
Пример #2
0
    def test_box_item_nested_references(self):
        item = {
            'node': {
                'k1': 'v1',
                'k2': 'v2',
                'reference': {
                    'edges': [
                        {
                            'node': {
                                'rk1': 'rv1',
                                'rk2': 'rv2',
                                'sortkey': 'B',
                                'reference': {
                                    'edges': [
                                        {
                                            'node': {
                                                'rrk1': 'rrv1',
                                                'rrk2': 'rrv2',
                                                'sortkey': 'rrB',
                                            }
                                        },
                                        {
                                            'node': {
                                                'rrk1': 'rrv1',
                                                'rrk2': 'rrv2',
                                                'sortkey': 'rrA',
                                            }
                                        }
                                    ]
                                }
                            },
                        },
                        {
                            'node': {
                                'rk1': 'rv1',
                                'rk2': 'rv2',
                                'sortkey': 'C'
                            },
                        },
                        {
                            'node': {
                                'rk1': 'rv1',
                                'rk2': 'rv2',
                                'sortkey': 'A'
                            },
                        }
                    ]
                }
            }
        }

        expected_result = [
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'B',
                                    'reference': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'rrk1': 'rrv1',
                                                    'rrk2': 'rrv2',
                                                    'sortkey': 'rrB',
                                                }
                                            },
                                        ]
                                    }
                                }
                            }
                        ]
                    }
                },
            },
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'B',
                                    'reference': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'rrk1': 'rrv1',
                                                    'rrk2': 'rrv2',
                                                    'sortkey': 'rrA',
                                                }
                                            },
                                        ]
                                    }
                                }
                            }
                        ]
                    }
                },
            },
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'C'
                                }
                            }
                        ]
                    }
                },
            },
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'A'
                                }
                            }
                        ]
                    }
                },
            }
        ]

        formatter = GraphQLResultFormatter()
        formatter._undouble = MagicMock(side_effect=lambda x: x)
        result = formatter._box_item(item)
        self.assertEqual(expected_result, result)
Пример #3
0
    def test_box_item_nested_references_same_level_cross_relations(self):
        item = {
            'node': {
                'k1': 'v1',
                'k2': 'v2',
                'reference': {
                    'edges': [
                        {
                            'node': {
                                'rk1': 'rv1',
                                'rk2': 'rv2',
                                'sortkey': 'B',
                                'reference': {
                                    'edges': [
                                        {
                                            'node': {
                                                'rrk1': 'rrv1',
                                                'rrk2': 'rrv2',
                                                'sortkey': 'rrB',
                                            }
                                        },
                                        {
                                            'node': {
                                                'rrk1': 'rrv1',
                                                'rrk2': 'rrv2',
                                                'sortkey': 'rrA',
                                            }
                                        }
                                    ]
                                },
                                'reference2': {
                                    'edges': [
                                        {
                                            'node': {
                                                'r2k1': 'r2v1'
                                            }
                                        },
                                        {
                                            'node': {
                                                'r2k2': 'r2v2',
                                            }
                                        }
                                    ]
                                }
                            },
                        },
                    ]
                }
            }
        }

        expected_result = [
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'B',
                                    'reference': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'rrk1': 'rrv1',
                                                    'rrk2': 'rrv2',
                                                    'sortkey': 'rrB',
                                                }
                                            },
                                        ]
                                    },
                                    'reference2': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'r2k1': 'r2v1'
                                                }
                                            },
                                        ]
                                    }
                                },
                            },
                        ]
                    }
                }
            },
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'B',
                                    'reference': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'rrk1': 'rrv1',
                                                    'rrk2': 'rrv2',
                                                    'sortkey': 'rrA',
                                                }
                                            }
                                        ]
                                    },
                                    'reference2': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'r2k1': 'r2v1'
                                                }
                                            },
                                        ]
                                    }
                                },
                            },
                        ]
                    }
                }
            },
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'B',
                                    'reference': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'rrk1': 'rrv1',
                                                    'rrk2': 'rrv2',
                                                    'sortkey': 'rrB',
                                                }
                                            },
                                        ]
                                    },
                                    'reference2': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'r2k2': 'r2v2',
                                                }
                                            }
                                        ]
                                    }
                                },
                            },
                        ]
                    }
                }
            },
            {
                'node': {
                    'k1': 'v1',
                    'k2': 'v2',
                    'reference': {
                        'edges': [
                            {
                                'node': {
                                    'rk1': 'rv1',
                                    'rk2': 'rv2',
                                    'sortkey': 'B',
                                    'reference': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'rrk1': 'rrv1',
                                                    'rrk2': 'rrv2',
                                                    'sortkey': 'rrA',
                                                }
                                            }
                                        ]
                                    },
                                    'reference2': {
                                        'edges': [
                                            {
                                                'node': {
                                                    'r2k2': 'r2v2',
                                                }
                                            }
                                        ]
                                    }
                                },
                            },
                        ]
                    }
                }
            },

        ]
        formatter = GraphQLResultFormatter(cross_relations=True)
        formatter._undouble = MagicMock(side_effect=lambda x: x)
        result = formatter._box_item(item)
        self.assertEqual(expected_result, result)
Пример #4
0
    def test_box_item_specific(self):

        item = {
            'node': {
                'identificatie': '0363200000403263',
                'huisnummer': 17,
                'huisletter': None,
                'huisnummertoevoeging': None,
                'postcode': '1015NR',
                'ligtAanOpenbareruimte': {
                    'edges': [
                        {
                            'node': {
                                'naam': 'Eerste Anjeliersdwarsstraat'
                            }
                        }
                    ]
                },
                'ligtInWoonplaats': {
                    'edges': [
                        {
                            'node': {
                                'naam': 'Amsterdam'
                            }
                        }
                    ]
                }
            }
        }

        expected_result = [{
            'node': {
                'identificatie': '0363200000403263',
                'huisnummer': 17,
                'huisletter': None,
                'huisnummertoevoeging': None,
                'postcode': '1015NR',
                'ligtAanOpenbareruimte': {
                    'edges': [
                        {
                            'node': {
                                'naam': 'Eerste Anjeliersdwarsstraat'
                            }
                        }
                    ]
                },
                'ligtInWoonplaats': {
                    'edges': [
                        {
                            'node': {
                                'naam': 'Amsterdam'
                            }
                        }
                    ]
                }
            }
        }]

        formatter = GraphQLResultFormatter()
        formatter._undouble = MagicMock(side_effect=lambda x: x)
        result = formatter._box_item(item)
        self.assertEqual(len(expected_result), len(result))
        self.assertEqual(expected_result, result)