def test_mutate__objects_exists__updates(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class BatchPatchDogMutation(DjangoBatchPatchMutation): class Meta: model = Dog class Mutations(graphene.ObjectType): batch_patch_dog = BatchPatchDogMutation.Field() dog_1 = DogFactory.create() dog_2 = DogFactory.create() user = UserFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation BatchPatchDog( $input: [BatchPatchDogInput]! ){ batchPatchDog(input: $input){ dogs{ id name } } } """ result = schema.execute(mutation, variables={ "input": [ { "id": to_global_id("DogNode", dog_1.id), "name": "New name 1", }, { "id": to_global_id("DogNode", dog_2.id), "name": "New name 2", }, ] }, context=Dict(user=user)) self.assertIsNone(result.errors) dogs = result.data["batchPatchDog"]["dogs"] dog_1_result = dogs[0] dog_2_result = dogs[1] self.assertEqual("New name 1", dog_1_result["name"]) self.assertEqual("New name 2", dog_2_result["name"]) dog_1.refresh_from_db() dog_2.refresh_from_db() self.assertEqual("New name 1", dog_1.name) self.assertEqual("New name 2", dog_2.name)
def test_field_types__specified__overrides_field_type(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class UpdateDogMutation(DjangoUpdateMutation): class Meta: model = Dog field_types = {"tag": graphene.Int()} @classmethod def handle_tag(self, value, *args, **kwargs): return f"Dog-{value}" class Mutations(graphene.ObjectType): update_dog = UpdateDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation UpdateDog( $id: ID!, $input: UpdateDogInput! ){ updateDog(id: $id, input: $input){ dog{ id } } } """ # Result with a string in the tag field should fail now result = schema.execute(mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "tag": "not-an-int", "breed": "HUSKY", "owner": to_global_id("UserNode", user.id) } }, context=Dict(user=user)) self.assertEqual(len(result.errors), 1) result = schema.execute(mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "breed": "HUSKY", "tag": 25, "owner": to_global_id("UserNode", user.id) } }, context=Dict(user=user)) self.assertIsNone(result.errors)
def test_many_to_many_extras__add_extra_by_input__adds_by_input(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class CreateCatMutation(DjangoCreateMutation): class Meta: model = Cat class UpdateDogMutation(DjangoUpdateMutation): class Meta: model = Dog many_to_many_extras = {"enemies": {"exact": {"type": "CreateCatInput"}}} class Mutations(graphene.ObjectType): create_cat = CreateCatMutation.Field() update_dog = UpdateDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() # Create some enemies cats = CatFactory.create_batch(5) self.assertEqual(dog.enemies.all().count(), 0) schema = Schema(mutation=Mutations) mutation = """ mutation UpdateDog( $id: ID!, $input: UpdateDogInput! ){ updateDog(id: $id, input: $input){ dog{ id } } } """ result = schema.execute( mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "tag": "tag", "breed": "HUSKY", "owner": to_global_id("UserNode", user.id), "enemies": [ {"name": cat.name, "owner": cat.owner.id} for cat in cats ], }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) dog.refresh_from_db() self.assertEqual(dog.enemies.all().count(), 5)
def test_many_to_many_extras__type_auto__makes_it_possible_to_add_new_full_objects( self, ): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class UpdateDogMutation(DjangoUpdateMutation): class Meta: model = Dog many_to_many_extras = {"enemies": {"add": {"type": "auto"}}} class Mutations(graphene.ObjectType): update_dog = UpdateDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() self.assertEqual(dog.enemies.all().count(), 0) schema = Schema(mutation=Mutations) mutation = """ mutation UpdateDog( $id: ID!, $input: UpdateDogInput! ){ updateDog(id: $id, input: $input){ dog{ id } } } """ result = schema.execute( mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "tag": "tag", "breed": "HUSKY", "owner": to_global_id("UserNode", user.id), "enemiesAdd": [{ "name": "Meowington", "owner": to_global_id("UserNode", user.id), }], }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) dog.refresh_from_db() self.assertEqual(dog.enemies.all().count(), 1)
def test_auto_type__with_proper_setup__generates_new_auto_type(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class UpdateDogMutation(DjangoUpdateMutation): class Meta: model = Dog foreign_key_extras = { "owner": { "type": "auto", "exclude_fields": ["password"] } } class Mutations(graphene.ObjectType): update_dog = UpdateDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation UpdateDog( $id: ID!, $input: UpdateDogInput! ){ updateDog(id: $id, input: $input){ dog{ id } } } """ result = schema.execute( mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "tag": "tag", "breed": "HUSKY", "owner": { "username": "******", "email": "*****@*****.**", "firstName": "Tormod", "lastName": "Haugland", }, }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) dog.refresh_from_db() self.assertEqual("*****@*****.**", dog.owner.email)
def test__filter_update__updates(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class FilterUpdateDogMutation(DjangoFilterUpdateMutation): class Meta: model = Dog filter_fields = ("name", "name__startswith") class Mutations(graphene.ObjectType): filter_update_dogs = FilterUpdateDogMutation.Field() dog = DogFactory.create(name="Simen") user = UserFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation FilterUpdateDog( $filter: FilterUpdateDogFilterInput!, $data: FilterUpdateDogDataInput! ){ filterUpdateDogs(filter: $filter, data: $data){ updatedCount updatedObjects{ id name tag } } } """ result = schema.execute( mutation, variables={ "filter": { "name_Startswith": "Sim" }, "data": { "tag": "New tag" }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) self.assertEqual( 1, len(result.data["filterUpdateDogs"]["updatedObjects"])) dog_result = result.data["filterUpdateDogs"]["updatedObjects"][0] self.assertEqual("New tag", dog_result["tag"]) dog.refresh_from_db() self.assertEqual("New tag", dog.tag)
def test_many_to_many_extras__calling_exact_with_empty_list__resets_relation(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class PatchDogMutation(DjangoPatchMutation): class Meta: model = Dog many_to_many_extras = {"enemies": {"exact": {"type": "ID"}}} class Mutations(graphene.ObjectType): patch_dog = PatchDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() # Create some enemies cats = CatFactory.create_batch(5) dog.enemies.set(cats) self.assertEqual(dog.enemies.all().count(), 5) schema = Schema(mutation=Mutations) mutation = """ mutation PatchDog( $id: ID!, $input: PatchDogInput! ){ patchDog(id: $id, input: $input){ dog{ id } } } """ result = schema.execute( mutation, variables={ "id": to_global_id("DogNode", dog.id), "input": { "name": "Sparky", "tag": "tag", "breed": "HUSKY", "owner": to_global_id("UserNode", user.id), "enemies": [], }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) dog.refresh_from_db() self.assertEqual(dog.enemies.all().count(), 0)
def test_default_setup__adding_resource_by_id__adds_resource(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class UpdateCatMutation(DjangoUpdateMutation): class Meta: model = Cat class Mutations(graphene.ObjectType): update_cat = UpdateCatMutation.Field() cat = CatFactory.create() user = UserFactory.create() dog = DogFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation UpdateCat( $id: ID!, $input: UpdateCatInput! ){ updateCat(id: $id, input: $input){ cat{ id } } } """ result = schema.execute( mutation, variables={ "id": to_global_id("CatNode", cat.id), "input": { "name": "Garfield", "owner": to_global_id("UserNode", user.id), "enemies": [to_global_id("DogNode", dog.id)], }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) cat.refresh_from_db() self.assertEqual(cat.enemies.all().count(), 1)
def test_custom_field__separate_from_model_fields__adds_new_field_which_can_be_handled( self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class CreateDogMutation(DjangoCreateMutation): class Meta: model = Dog custom_fields = {"bark": graphene.Boolean()} @classmethod def before_save(cls, root, info, input, obj): if input.get("bark"): obj.bark_count += 1 return obj class Mutations(graphene.ObjectType): create_dog = CreateDogMutation.Field() dog = DogFactory.create() user = UserFactory.create() schema = Schema(mutation=Mutations) mutation = """ mutation CreateDog( $input: CreateDogInput! ){ createDog(input: $input){ dog{ id barkCount } } } """ self.assertEqual(0, dog.bark_count) result = schema.execute( mutation, variables={ "input": { "name": "Sparky", "tag": "tag", "breed": "HUSKY", "bark": True, "owner": to_global_id("UserNode", user.id) }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) self.assertEqual(1, result.data["createDog"]["dog"]["barkCount"]) result = schema.execute( mutation, variables={ "input": { "name": "Sparky", "tag": "tag-2", "breed": "HUSKY", "owner": to_global_id("UserNode", user.id) }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) self.assertEqual(0, result.data["createDog"]["dog"]["barkCount"])
def test__reverse_one_to_one_exists__updates_specified_fields(self): # This registers the UserNode type # noinspection PyUnresolvedReferences from .schema import UserNode class UpdateDogRegistrationMutation(DjangoUpdateMutation): class Meta: model = DogRegistration one_to_one_extras = {"dog": {"type": "auto"}} class Mutations(graphene.ObjectType): update_dog_registration = UpdateDogRegistrationMutation.Field() user = UserFactory.create() dog = DogFactory.create(breed="HUSKY") dog_registration = DogRegistration.objects.create( dog=dog, registration_number="1234") schema = Schema(mutation=Mutations) mutation = """ mutation UpdateDogRegistration( $id: ID!, $input: UpdateDogRegistrationInput! ){ updateDogRegistration(id: $id, input: $input){ dogRegistration{ id registrationNumber dog{ id breed } } } } """ result = schema.execute( mutation, variables={ "id": to_global_id("DogRegistrationNode", dog_registration.id), "input": { "registrationNumber": dog_registration.registration_number, "dog": { "name": dog.name, "breed": "LABRADOR", "tag": dog.tag, "owner": to_global_id("UserNode", dog.owner.id), }, }, }, context=Dict(user=user), ) self.assertIsNone(result.errors) data = Dict(result.data) self.assertEqual("LABRADOR", data.updateDogRegistration.dogRegistration.dog.breed) # Load from database dog_registration.refresh_from_db() dog.refresh_from_db() self.assertEqual(dog.breed, "LABRADOR")