Ejemplo n.º 1
0
 def test_swap_failure(self):
     data = [{
         'id': 1,
         'title': 'One',
         'baz': [{
             'id': 2
         }, {
             'id': 1,
             'bar': {
                 'id': 1
             }
         }]
     }]
     norm = Normalize()
     norm.define_primary('foo')
     norm.swap_primary('blah')
     try:
         norm.parse(data)
         self.assertTrue(False)
     except ValueError:
         self.assertTrue(True)
Ejemplo n.º 2
0
 def test_set_primary_swap(self):
     norm = Normalize()
     norm.swap_primary('test')
     self.assertEqual(norm.swap_primary_to, 'test')
Ejemplo n.º 3
0
    def test_parse(self):
        norm = Normalize()
        norm.define_primary('test', 'ID')
        try:
            norm.parse([{'id': 1, 'title': 'Some Article'}])
            self.assertTrue(False)
        except ValueError:
            self.assertTrue(True)

        norm = Normalize()
        norm.define_primary('test')
        self.assertEqual(
            norm.parse([{
                'id': 1,
                'title': 'Some Article'
            }]), {
                'entities': {
                    'test': {
                        1: {
                            'id': 1,
                            'title': 'Some Article'
                        }
                    }
                },
                'results': [1]
            })
        norm = Normalize()
        norm.define_primary('foo')
        norm.define_nested_entity('bar', 'baz')
        norm.define_nested_entity('asdf', 'qwer')
        self.assertEqual(norm.parse([]), None)
        self.assertEqual(
            norm.parse([{
                'id': 1,
                'title': 'One',
                'baz': {
                    'id': 1
                }
            }, {
                'id': 2,
                'title': 'Two',
                'baz': {
                    'id': 2
                }
            }]), {
                'entities': {
                    'foo': {
                        1: {
                            'baz': [1],
                            'id': 1,
                            'title': 'One'
                        },
                        2: {
                            'baz': [2],
                            'id': 2,
                            'title': 'Two'
                        }
                    },
                    'asdf': {},
                    'bar': {
                        1: {
                            'id': 1
                        },
                        2: {
                            'id': 2
                        }
                    }
                },
                'results': [1, 2]
            })

        data = [{
            'id': 1,
            'title': 'One',
            'baz': [{
                'id': 2
            }, {
                'id': 1,
                'bar': {
                    'id': 1
                }
            }]
        }]
        norm = Normalize()
        norm.define_primary('foo')
        norm.define_nested_entity('test', 'baz')
        self.assertEqual(
            norm.parse(data), {
                'entities': {
                    'test': {
                        1: {
                            'bar': {
                                'id': 1
                            },
                            'id': 1
                        },
                        2: {
                            'id': 2
                        }
                    },
                    'foo': {
                        1: {
                            'baz': [2, 1],
                            'id': 1,
                            'title': 'One'
                        }
                    }
                },
                'results': [1]
            })

        data = [{
            'id': 1,
            'title': 'One',
            'baz': [{
                'id': 2
            }, {
                'id': 1,
                'bar': {
                    'id': 1
                }
            }]
        }]
        norm = Normalize()
        norm.define_primary('foo')
        norm.define_nested_entity('test', 'baz')
        norm.swap_primary('test')
        self.assertEqual(
            norm.parse(data), {
                'entities': {
                    'test': {
                        1: {
                            'bar': {
                                'id': 1
                            },
                            'id': 1
                        },
                        2: {
                            'id': 2
                        }
                    },
                    'foo': {
                        1: {
                            'baz': [2, 1],
                            'id': 1,
                            'title': 'One'
                        }
                    }
                },
                'results': [1, 2]
            })

        data = [{
            'id': 1,
            'title': 'One',
            'baz': [{
                'id': 2
            }, {
                'id': 1,
                'bar': {
                    'id': 1
                }
            }]
        }]
        norm = Normalize()
        norm.define_primary('foo')
        norm.define_nested_entity('test', 'baz')
        norm.swap_primary('test')
        norm.add_one_to_many_key('foo_ids', 'id', 'test', 'foo')
        self.assertEqual(
            norm.parse(data), {
                'entities': {
                    'test': {
                        1: {
                            'foo_ids': [1],
                            'bar': {
                                'id': 1
                            },
                            'id': 1
                        },
                        2: {
                            'foo_ids': [],
                            'id': 2
                        }
                    },
                    'foo': {
                        1: {
                            'baz': [2, 1],
                            'id': 1,
                            'title': 'One'
                        }
                    }
                },
                'results': [1, 2]
            })

        data = [{
            'id': 1,
            'title': 'One',
            'baz': [{
                'id': 1,
                'bar': {
                    'id': 1
                }
            }]
        }]
        norm = Normalize()
        norm.define_primary('foo')
        norm.define_nested_entity('test', 'baz')
        self.assertEqual(
            norm.parse(data), {
                'entities': {
                    'test': {
                        1: {
                            'bar': {
                                'id': 1
                            },
                            'id': 1
                        }
                    },
                    'foo': {
                        1: {
                            'baz': [1],
                            'id': 1,
                            'title': 'One'
                        }
                    }
                },
                'results': [1]
            })