class ModelsTestCase(GraphTestCase):

    def setUp(self):
        self._registry = GraphModelRegistry()
        self._registry.register(Node, NodeSerializer)
        self._registry.register(Relationship, RelationshipSerializer)

        super(ModelsTestCase, self).setUp()

    def test_relationship_label(self):
        node1 = Node.objects.create()
        node2 = Node.objects.create()

        relationship = Relationship.objects.create(
            start_node=node1.id, end_node=node2.id
        )

        self.assertTrue(relationship.label, 'Relationship')

    def test_register_non_graph_model(self):
        class BadModel(models.Model):
            foo = models.CharField(max_length=25)

        class BadSerializer(serializers.ModelSerializer):
            class Meta:
                model = BadModel

        def _register_models():
            self._registry.register(BadModel, BadSerializer)

        self.assertRaises(ModelRegistrationError, _register_models)
    def setUp(self):
        self._registry = GraphModelRegistry()
        self._registry.register(Node, NodeSerializer)
        self._registry.register(Relationship, RelationshipSerializer)

        graph_databases = getattr(settings, 'GRAPH_DATABASES')
        connection_options = graph_databases.get('test')

        if not connection_options:
            connection_options = graph_databases.get('default')

        connection_options['IS_TEST'] = True

        self._backend = Neo4jBackend('test', self._registry, **connection_options)

        super(Neo4jBackendTestCase, self).setUp()
class SerializationTestCase(GraphTestCase):
    def setUp(self):
        self._registry = GraphModelRegistry()
        self._registry.register(Node, NodeSerializer)
        self._registry.register(Relationship, RelationshipSerializer)

        super(SerializationTestCase, self).setUp()

    def test_node_serialization(self):
        start_node = Node.objects.create()
        start_node_serialized = self._registry.serialize_obj(start_node)
        start_node_keys = list(start_node_serialized.keys())
        expected_node_keys = ['id', 'created', 'modified']

        self.assertListEqual(start_node_keys, expected_node_keys)

    def test_relationship_serialization(self):
        start_node = Node.objects.create()
        end_node = Node.objects.create()
        relationship = Relationship.objects.create(
            start_node=start_node.pk,
            end_node=end_node.pk
        )
        relationship_serialized = self._registry.serialize_obj(relationship)
        expected_keys = ['id', 'created', 'modified', 'start_node', 'end_node', 'label']

        self.assertEqual(list(relationship_serialized.keys()), expected_keys)
        self.assertEqual(relationship_serialized.get('id'), str(relationship.id))
        self.assertEqual(relationship_serialized.get('start_node'), str(relationship.start_node))
        self.assertEqual(relationship_serialized.get('end_node'), str(relationship.end_node))

    def test_relationship_deserialization(self):
        relationship = {
            'id': '0f87ffac-d532-43e6-ad2e-4c5dfda86e83',
            'end_node': '3acfeb1e-f0d8-43b3-a9f1-32d2f632f499',
            'created': u'2015-06-26T22:07:20.089414Z',
            'modified': u'2015-06-26T22:07:20.090105Z',
            'label': u'Relationship',
            'start_node': '7f7f0f81-5833-4502-9e4c-7db484164b5d'
        }

        relationship_deserialized = self._registry.deserialize_obj(relationship, Relationship)
        self.assertEqual(relationship_deserialized.get('start_node'), uuid.UUID(relationship.get('start_node')))
    def setUp(self):
        self._registry = GraphModelRegistry()
        self._registry.register(Node, NodeSerializer)
        self._registry.register(Relationship, RelationshipSerializer)

        super(ModelsTestCase, self).setUp()
class Neo4jBackendTestCase(GraphTestCase):
    def setUp(self):
        self._registry = GraphModelRegistry()
        self._registry.register(Node, NodeSerializer)
        self._registry.register(Relationship, RelationshipSerializer)

        graph_databases = getattr(settings, 'GRAPH_DATABASES')
        connection_options = graph_databases.get('test')

        if not connection_options:
            connection_options = graph_databases.get('default')

        connection_options['IS_TEST'] = True

        self._backend = Neo4jBackend('test', self._registry, **connection_options)

        super(Neo4jBackendTestCase, self).setUp()

    def tearDown(self):
        self._backend.delete_test_data()
        super(Neo4jBackendTestCase, self).tearDown()

    def test_create_node(self):
        node = Node.objects.create()
        self._backend.create_node(node)

        graph_node = self._backend.get_node(node.id)

        self.assertEqual(graph_node.get('id'), str(node.id))

    def test_update_node(self):
        node = Node.objects.create()
        self._backend.create_node(node)

        graph_node = self._backend.get_node(node.id)

        created = graph_node.get('created')
        modified = graph_node.get('modified')

        node.save()

        self._backend.update_node(node)

        updated_graph_node = self._backend.get_node(node.id)

        updated_created = updated_graph_node.get('created')
        updated_modified = updated_graph_node.get('modified')

        self.assertEqual(graph_node.get('id'), updated_graph_node.get('id'))

        self.assertEqual(created, updated_created)
        self.assertLess(modified, updated_modified)

    def test_delete_node(self):
        node = Node.objects.create()
        self._backend.create_node(node)

        self._backend.delete_node(node)

        def _get_deleted_node():
            self._backend.get_node(str(node.id))

        self.assertRaises(GraphObjectNotFound, _get_deleted_node)

    def test_create_relationship(self):
        node1 = Node.objects.create()
        node2 = Node.objects.create()

        relationship = Relationship.objects.create(
            start_node=node1.id, end_node=node2.id
        )

        self._backend.create_node(node1)
        self._backend.create_node(node2)
        self._backend.create_relationship(relationship)

        relationships = self._backend.match(start_node=node1, end_node=node2, rel_type=Relationship)

        self.assertEqual(relationships[0].get('id'), str(relationship.id))
        self.assertEqual(relationships[0].get('start_node'), str(node1.id))
        self.assertEqual(relationships[0].get('end_node'), str(node2.id))
        self.assertEqual(relationships[0].get('label'), 'Relationship')

    def test_update_relationship(self):
        node1 = Node.objects.create()
        node2 = Node.objects.create()

        relationship = Relationship.objects.create(
            start_node=node1.id, end_node=node2.id
        )

        self._backend.create_node(node1)
        self._backend.create_node(node2)
        self._backend.create_relationship(relationship)

        relationships = self._backend.match(start_node=node1, end_node=node2, rel_type=Relationship)

        created = relationships[0].get('created')
        modified = relationships[0].get('modified')

        relationship.save()

        self._backend.update_relationship(relationship)

        relationships = self._backend.match(start_node=node1, end_node=node2, rel_type=Relationship)

        updated_created = relationships[0].get('created')
        updated_modified = relationships[0].get('modified')

        self.assertEqual(created, updated_created)
        self.assertLess(modified, updated_modified)

    def test_delete_relationship(self):
        node1 = Node.objects.create()
        node2 = Node.objects.create()

        relationship = Relationship.objects.create(
            start_node=node1.id, end_node=node2.id
        )

        self._backend.create_node(node1)
        self._backend.create_node(node2)
        self._backend.create_relationship(relationship)

        self._backend.delete_relationship(relationship)

        relationships = self._backend.match(start_node=node1, end_node=node2, rel_type=Relationship)

        self.assertListEqual(relationships, [])