def test_add_shipping_to_checkout( api_client, checkout_with_shipping_address, shipping_method, count_queries, ): query = ( FRAGMENT_CHECKOUT + """ mutation updateCheckoutShippingOptions( $checkoutId: ID!, $shippingMethodId: ID! ) { checkoutShippingMethodUpdate( checkoutId: $checkoutId, shippingMethodId: $shippingMethodId ) { errors { field message } checkout { ...Checkout } } } """ ) variables = { "checkoutId": Node.to_global_id("Checkout", checkout_with_shipping_address.pk), "shippingMethodId": Node.to_global_id("ShippingMethod", shipping_method.pk), } response = get_graphql_content(api_client.post_graphql(query, variables)) assert not response["data"]["checkoutShippingMethodUpdate"]["errors"]
def test_update_checkout_lines( api_client, checkout_with_items, stock, product_with_default_variant, product_with_single_variant, product_with_two_variants, count_queries, ): variables = { "token": checkout_with_items.token, "lines": [ { "quantity": 1, "variantId": Node.to_global_id("ProductVariant", stock.product_variant.pk), }, { "quantity": 2, "variantId": Node.to_global_id( "ProductVariant", product_with_default_variant.variants.first().pk, ), }, { "quantity": 10, "variantId": Node.to_global_id( "ProductVariant", product_with_single_variant.variants.first().pk, ), }, { "quantity": 3, "variantId": Node.to_global_id( "ProductVariant", product_with_two_variants.variants.first().pk, ), }, { "quantity": 2, "variantId": Node.to_global_id( "ProductVariant", product_with_two_variants.variants.last().pk, ), }, ], } response = get_graphql_content( api_client.post_graphql(MUTATION_CHECKOUT_LINES_UPDATE, variables)) assert not response["data"]["checkoutLinesUpdate"]["errors"]
class UsersQuery(object): user = Node.Field(types.UserNode) all_users = DjangoFilterConnectionField( types.UserNode, filterset_class=filters.UserFilter, ) auth_group = Node.Field(types.AuthGroupNode) all_auth_groups = DjangoFilterConnectionField( types.AuthGroupNode, filterset_class=filters.AuthGroupFilter, ) auth_permission = Node.Field(types.AuthPermissionNode) all_auth_permissions = DjangoFilterConnectionField( types.AuthPermissionNode, filterset_class=filters.AuthPermissionFilter, ) content_type = Node.Field(types.ContentTypeNode) all_content_types = DjangoFilterConnectionField( types.ContentTypeNode, filterset_class=filters.ContentTypeFilter, ) current_user = Field(types.UserNode) def resolve_current_user(self, info): if info.context.user.is_authenticated: return info.context.user
def test_save_pipeline_schedules_nonadmin( graphql_client, pipeline_sequence_3, pipeline_sequence_1, pipeline_sequence_2, pipeline_sequence_4, pipeline_sequence_5, ): ps_id_2 = Node.to_global_id('PipelineSequence', pipeline_sequence_2.id) ps_id_3 = Node.to_global_id('PipelineSequence', pipeline_sequence_3.id) res = graphql_client.post(save_pipeline_schedules_query, variables={ 'input': { 'clientMutationId': 'testmutation', 'pipelineSchedules': [ { 'id': ps_id_3, 'isFullActive': False, 'isUpdateActive': True, }, { 'id': ps_id_2, 'isFullActive': True, 'isUpdateActive': False, }, ], }, }) assert res['data']['savePipelineSchedules'] is None assert '401 Unauthorized' in res['errors'][0]['message']
class Query(object): stud = Node.Field(StudNode) all_stud = DjangoFilterConnectionField(StudNode) ingredient = Node.Field(IngredientNode) all_ingredients = DjangoFilterConnectionField(IngredientNode)
def test_checkout_update_shipping_method(api_client, checkout_with_digital_item, address, shipping_method): """Test updating the shipping method of a digital order throws an error.""" checkout = checkout_with_digital_item checkout_id = Node.to_global_id("Checkout", checkout.pk) method_id = Node.to_global_id("ShippingMethod", shipping_method.pk) variables = {"checkoutId": checkout_id, "shippingMethodId": method_id} # Put a shipping address, to ensure it is still handled properly checkout.shipping_address = address checkout.save(update_fields=["shipping_address"]) response = api_client.post_graphql(MUTATION_UPDATE_SHIPPING_METHOD, variables) content = get_graphql_content(response) data = content["data"]["checkoutShippingMethodUpdate"] assert data["errors"] == [{ "field": "shippingMethod", "message": "This checkout doesn't need shipping" }] # Ensure the shipping method was unchanged checkout.refresh_from_db(fields=["shipping_method"]) assert checkout.shipping_method is None
class Query(AbstractType): user = Node.Field(UserNode) all_users = DjangoFilterConnectionField(UserNode) developer = Node.Field(DeveloperNode) all_developers = DjangoFilterConnectionField(DeveloperNode) project = Node.Field(ProjectNode) all_projects = DjangoFilterConnectionField(ProjectNode)
def _wrapper(node): node_name = node.__name__.lower()[:-4] meta = query._meta meta.fields[node_name] = Node.Field(node) meta.fields['all_' + node_name] = DjangoFilterConnectionField(node) query._meta.fields[node_name] = Node.Field(node) setattr(query, '_meta', meta) return node
class Query(graphene.ObjectType): class Meta: abstract = True client = Node.Field(ClientType) all_clients = DjangoFilterConnectionField(ClientType) project = Node.Field(ProjectType) all_projects = DjangoFilterConnectionField(ProjectType)
class Query(graphene.ObjectType): user = Node.Field(UserNode) users = DjangoFilterConnectionField(UserNode) officer = Node.Field(OfficerNode) officers = DjangoFilterConnectionField(OfficerNode) officer_position = Node.Field(OfficerNode) officer_positions = DjangoFilterConnectionField(OfficerNode)
def test_create_checkout( api_client, graphql_address_data, stock, channel_USD, product_with_default_variant, product_with_single_variant, product_with_two_variants, count_queries, ): checkout_counts = Checkout.objects.count() variables = { "checkoutInput": { "channel": channel_USD.slug, "email": "*****@*****.**", "shippingAddress": graphql_address_data, "lines": [ { "quantity": 1, "variantId": Node.to_global_id( "ProductVariant", stock.product_variant.pk ), }, { "quantity": 2, "variantId": Node.to_global_id( "ProductVariant", product_with_default_variant.variants.first().pk, ), }, { "quantity": 10, "variantId": Node.to_global_id( "ProductVariant", product_with_single_variant.variants.first().pk, ), }, { "quantity": 3, "variantId": Node.to_global_id( "ProductVariant", product_with_two_variants.variants.first().pk, ), }, { "quantity": 2, "variantId": Node.to_global_id( "ProductVariant", product_with_two_variants.variants.last().pk, ), }, ], } } get_graphql_content(api_client.post_graphql(MUTATION_CHECKOUT_CREATE, variables)) assert checkout_counts + 1 == Checkout.objects.count()
class RecipesQuery(object): recipe = Node.Field(types.RecipeNode) all_recipes = DjangoFilterConnectionField( types.RecipeNode, filterset_class=filters.RecipeFilter, ) ingredient = Node.Field(types.IngredientNode) all_ingredients = DjangoFilterConnectionField( types.IngredientNode, filterset_class=filters.IngredientFilter, ) step = Node.Field(types.StepNode) all_steps = DjangoFilterConnectionField( types.StepNode, filterset_class=filters.StepFilter, ) recipe_step_relationship = Node.Field(types.RecipeStepRelationshipNode) all_recipe_step_relationships = DjangoFilterConnectionField( types.RecipeStepRelationshipNode, filterset_class=filters.RecipeStepRelationshipFilter, ) def resolve_all_recipes(self, info, **kwargs): down_vote = getattr(ACTIVITY_TYPES, 'down_vote') up_vote = getattr(ACTIVITY_TYPES, 'up_vote') comments_filter = Q(comments__active=True) down_votes_filter = (Q(user_activities__active=True) & Q(user_activities__activity_type=down_vote)) up_votes_filter = (Q(user_activities__active=True) & Q(user_activities__activity_type=up_vote)) total_steps = Count('steps', distinct=True) total_ingredients = Count('ingredients', distinct=True) total_comments = Count('comments', filter=comments_filter, distinct=True) total_down_votes = Count('user_activities', filter=down_votes_filter, distinct=True) total_up_votes = Count('user_activities', filter=up_votes_filter, distinct=True) return Recipe.objects \ .select_related('author') \ .annotate(total_steps=total_steps) \ .annotate(total_ingredients=total_ingredients) \ .annotate(total_comments=total_comments) \ .annotate(total_down_votes=total_down_votes) \ .annotate(total_up_votes=total_up_votes) \ .all()
def test_create_checkout_for_cc( api_client, graphql_address_data, channel_USD, stocks_for_cc, product_variant_list, count_queries, ): query = ( FRAGMENT_CHECKOUT_FOR_CC + """ mutation CreateCheckout($checkoutInput: CheckoutCreateInput!) { checkoutCreate(input: $checkoutInput) { errors { field message } checkout { ...Checkout } } } """ ) checkout_counts = Checkout.objects.count() variables = { "checkoutInput": { "channel": channel_USD.slug, "email": "*****@*****.**", "shippingAddress": graphql_address_data, "lines": [ { "quantity": 1, "variantId": Node.to_global_id( "ProductVariant", stocks_for_cc[0].product_variant.pk ), }, { "quantity": 2, "variantId": Node.to_global_id( "ProductVariant", product_variant_list[0].pk, ), }, { "quantity": 5, "variantId": Node.to_global_id( "ProductVariant", product_variant_list[1].pk, ), }, ], } } get_graphql_content(api_client.post_graphql(query, variables)) assert checkout_counts + 1 == Checkout.objects.count()
class Query(graphene.ObjectType): user = Node.Field(UserNode) cat = Node.Field(CatNode) dog = Node.Field(DogNode) mice = Node.Field(MouseNode) all_users = DjangoConnectionField(UserNode) all_cats = DjangoConnectionField(CatNode) all_dogs = DjangoConnectionField(DogNode) all_mice = DjangoConnectionField(MouseNode)
class Query(ObjectType): genre = Node.Field(GenreNode) all_genres = DjangoConnectionField(GenreNode) job = Node.Field(JobNode) all_jobs = DjangoConnectionField(JobNode) person = Node.Field(PersonNode) all_persons = DjangoConnectionField(PersonNode) movie = Node.Field(MovieNode) all_movies = DjangoConnectionField(MovieNode)
def test_pipeline_sequence_list_order_by_end_time_desc( graphql_client_admin, pipeline_sequence_3, pipeline_sequence_1, pipeline_sequence_2, pipeline_sequence_4, pipeline_sequence_5, ): ps_id_1 = pipeline_sequence_1.id ps_id_3 = pipeline_sequence_3.id ps_id_4 = pipeline_sequence_4.id res = graphql_client_admin.post(pipeline_sequence_list_query, variables={ 'offset': 1, 'first': 3, 'sort': 'end_time_desc', }) expected = {'data': {'scheduleManagement': {'pipelineSequences': {'edges': [ {'node': {'comments': 'comments1', 'id': Node.to_global_id('PipelineSequence', ps_id_1), 'source': {'name': 'source_1'}, 'isActive': True, 'isFullActive': True, 'isUpdateActive': False, 'isFullInProgress': False, 'isUpdateInProgress': False, 'startTime': '2018-01-15T21:30:13.000155', 'endTime': '2018-01-15T21:30:16.000295', 'state': 'state1'}}, {'node': {'comments': 'comments4', 'id': Node.to_global_id('PipelineSequence', ps_id_4), 'source': {'name': 'source_source_4'}, 'isActive': True, 'isFullActive': True, 'isUpdateActive': False, 'isFullInProgress': False, 'isUpdateInProgress': False, 'startTime': '2018-01-14T21:30:13.000155', 'endTime': '2018-01-14T21:30:16.000295', 'state': 'ready'}}, {'node': {'comments': 'comments3', 'id': Node.to_global_id('PipelineSequence', ps_id_3), 'source': {'name': 'source_3'}, 'isActive': True, 'isFullActive': True, 'isUpdateActive': False, 'isFullInProgress': True, 'isUpdateInProgress': False, 'startTime': '2018-01-13T21:33:13.000153', 'endTime': '2018-01-13T21:33:16.000235', 'state': 'queued'}}, ], 'totalCount': 5}}}} assert res == expected
def test_pipeline_sequence_list_default_order( graphql_client_admin, pipeline_sequence_3, pipeline_sequence_1, pipeline_sequence_2, pipeline_sequence_4, pipeline_sequence_5, ): ps_id_2 = pipeline_sequence_2.id ps_id_3 = pipeline_sequence_3.id ps_id_5 = pipeline_sequence_5.id res = graphql_client_admin.post(pipeline_sequence_list_query, variables={ 'offset': 1, 'first': 3, }) expected = {'data': {'scheduleManagement': {'pipelineSequences': {'edges': [ {'node': {'comments': 'comments2', 'id': Node.to_global_id('PipelineSequence', ps_id_2), 'source': {'name': 'source_2'}, 'isActive': False, 'isFullActive': False, 'isUpdateActive': False, 'isFullInProgress': False, 'isUpdateInProgress': False, 'startTime': '2018-02-15T21:30:13.000155', 'endTime': '2018-02-15T21:30:16.000295', 'state': 'error'}}, {'node': {'comments': 'comments3', 'id': Node.to_global_id('PipelineSequence', ps_id_3), 'source': {'name': 'source_3'}, 'isActive': True, 'isFullActive': True, 'isUpdateActive': False, 'isFullInProgress': True, 'isUpdateInProgress': False, 'startTime': '2018-01-13T21:33:13.000153', 'endTime': '2018-01-13T21:33:16.000235', 'state': 'queued'}}, {'node': {'comments': 'comments5', 'id': Node.to_global_id('PipelineSequence', ps_id_5), 'source': {'name': 'source_no_shipping'}, 'isActive': False, 'isFullActive': False, 'isUpdateActive': False, 'isFullInProgress': False, 'isUpdateInProgress': False, 'startTime': '2017-01-15T21:30:13.000155', 'endTime': '2017-01-15T21:30:16.000295', 'state': 'ready'}}, ], 'totalCount': 5}}}} assert res == expected
class Query(object): game = Node.Field(Game) all_games = DjangoFilterConnectionField(Game) item = Node.Field(Item) all_items = DjangoFilterConnectionField(Item) recipe = Node.Field(Recipe) all_recipes = DjangoFilterConnectionField(Recipe) station = Node.Field(Station) all_stations = DjangoFilterConnectionField(Station)
class Query(graphene.ObjectType): class Meta: abstract = True client = Node.Field(ClientType) all_clients = DjangoFilterConnectionField(ClientType) employee = Node.Field(EmployeeType) all_employees = DjangoFilterConnectionField(EmployeeType) office = Node.Field(OfficeType) all_offices = DjangoFilterConnectionField(OfficeType)
class Query(object): all_seasons = graphene.List(SeasonType) all_skins = graphene.List(SkinType) """ Skins will return one result matching the search""" skins = graphene.Field(SkinType, id=graphene.Int(), name = graphene.String(), rarity = graphene.String(), price = graphene.Int(), first_seen = graphene.String() ) fortniteskins = Node.Field(RarityNode) all_rarity = DjangoFilterConnectionField(RarityNode) skins_price = Node.Field(PriceNode) all_price = DjangoFilterConnectionField(PriceNode) def resolve_all_seasons(self, info, **kwargs): return season.objects.all() def resolve_all_skins(self, info, **kwargs): return fortniteskins.objects.all() def resolve_skins(self, info, **kwargs): id = kwargs.get('id') name = kwargs.get('name') rarity = kwargs.get('rarity') price = kwargs.get('price') first_seen = kwargs.get('first_seen') outfit_img = kwargs.get('outfit_img') if id is not None: return fortniteskins.objects.get(pk=id) if name is not None: return fortniteskins.objects.get(name=name) if rarity is not None: return fortniteskins.objects.get(rarity=rarity) if price is not None: return fortniteskins.objects.get(price=price) if first_seen is not None: return fortniteskins.objects.get(first_seen=first_seen) if outfit_img is not None: return fortniteskins.objects.get(outfit_img=outfit_img) return None
class Query(AbstractType): meetup = Node.Field(MeetupNode) all_meetups = DjangoFilterConnectionField(MeetupNode) attendee = Node.Field(AttendeeNode) all_attendees = DjangoFilterConnectionField(AttendeeNode) my_meetups = DjangoFilterConnectionField(MeetupNode) def resolve_my_meetups(self, args, context, info): if not context.user.is_authenticated(): return MeetupModel.objects.none() else: return MeetupModel.objects.filter(attendee__user=context.user, **args)
class Query(ObjectType): user = Node.Field(UserNode) all_users = DjangoConnectionField(UserNode) kit = Node.Field(KitNode) all_kits = DjangoConnectionField(KitNode) adapter = Node.Field(AdapterNode) all_adapters = DjangoConnectionField(AdapterNode) run = Node.Field(RunNode) all_runs = DjangoConnectionField(RunNode) database = Node.Field(DatabaseNode) all_databases = DjangoConnectionField(DatabaseNode)
class Query(object): user = Node.Field(UserNode) all_users = DjangoFilterConnectionField(UserNode) account = Node.Field(AccountNode) all_accounts = DjangoFilterConnectionField(AccountNode) cashier = Node.Field(CashierNode) all_cashiers = DjangoFilterConnectionField(CashierNode) clasification = Node.Field(ClasificationNode) all_clasifications = DjangoFilterConnectionField(ClasificationNode) transaction = Node.Field(TransactionNode) all_transactions = DjangoFilterConnectionField(TransactionNode)
class Query(AbstractType): event = Node.Field(EventNode) all_events = DjangoFilterConnectionField(EventNode) event_attendee = Node.Field(EventAttendeeNode) all_event_attendees = DjangoFilterConnectionField(EventAttendeeNode) my_events = DjangoFilterConnectionField(EventNode) event_image = Node.Field(EventImageNode) all_event_images = DjangoFilterConnectionField(EventImageNode) def resolve_my_events(self, args, context, info): if not context.user.is_authenticated(): return EventModel.objects.none() else: return EventModel.objects.filter(attendee__user=context.user, **args)
class Query(ObjectType): app = Node.Field(AppType) all_apps = DjangoFilterConnectionField(AppType) like = Node.Field(AppLikeType) all_likes = DjangoFilterConnectionField(AppLikeType) seerah_question = Node.Field(SeerahQuestionType) all_seerah_questions = DjangoFilterConnectionField(SeerahQuestionType) seerah_topic = Node.Field(SeerahTopicType) all_seerah_topics = DjangoFilterConnectionField(SeerahTopicType) dictionary = Node.Field(DictionaryType) all_dis = DjangoFilterConnectionField(DictionaryType)
def test_checkout_payment_charge( api_client, checkout_with_billing_address, count_queries ): query = """ mutation createPayment($input: PaymentInput!, $checkoutId: ID!) { checkoutPaymentCreate(input: $input, checkoutId: $checkoutId) { errors { field message } } } """ variables = { "checkoutId": Node.to_global_id("Checkout", checkout_with_billing_address.pk), "input": { "amount": calculations.checkout_total( checkout=checkout_with_billing_address, lines=list(checkout_with_billing_address), ).gross.amount, "gateway": "mirumee.payments.dummy", "token": "charged", }, } response = get_graphql_content(api_client.post_graphql(query, variables)) assert not response["data"]["checkoutPaymentCreate"]["errors"]
def test_checkout_voucher_code( api_client, checkout_with_billing_address, voucher, count_queries ): query = ( FRAGMENT_CHECKOUT + """ mutation AddCheckoutPromoCode($checkoutId: ID!, $promoCode: String!) { checkoutAddPromoCode(checkoutId: $checkoutId, promoCode: $promoCode) { checkout { ...Checkout } errors { field message } checkoutErrors { field message code } } } """ ) variables = { "checkoutId": Node.to_global_id("Checkout", checkout_with_billing_address.pk), "promoCode": voucher.code, } response = get_graphql_content(api_client.post_graphql(query, variables)) assert not response["data"]["checkoutAddPromoCode"]["errors"]
def test_checkout_email_update(api_client, checkout_with_variants, count_queries): query = ( FRAGMENT_CHECKOUT + """ mutation UpdateCheckoutEmail( $checkoutId: ID!, $email: String! ) { checkoutEmailUpdate(checkoutId: $checkoutId, email: $email) { checkout { ...Checkout } errors { field message } } } """ ) variables = { "checkoutId": Node.to_global_id("Checkout", checkout_with_variants.pk), "email": "*****@*****.**", } response = get_graphql_content(api_client.post_graphql(query, variables)) assert not response["data"]["checkoutEmailUpdate"]["errors"]
def test_checkout_shipping_address_update( api_client, graphql_address_data, checkout_with_variants, count_queries ): query = ( FRAGMENT_CHECKOUT + """ mutation UpdateCheckoutShippingAddress( $checkoutId: ID!, $shippingAddress: AddressInput! ) { checkoutShippingAddressUpdate( checkoutId: $checkoutId, shippingAddress: $shippingAddress ) { errors { field message } checkout { ...Checkout } } } """ ) variables = { "checkoutId": Node.to_global_id("Checkout", checkout_with_variants.pk), "shippingAddress": graphql_address_data, } response = get_graphql_content(api_client.post_graphql(query, variables)) assert not response["data"]["checkoutShippingAddressUpdate"]["errors"]
def test_complete_checkout(api_client, checkout_with_charged_payment, count_queries): query = """ mutation completeCheckout($checkoutId: ID!, $redirectUrl: String) { checkoutComplete(checkoutId: $checkoutId, redirectUrl: $redirectUrl) { errors { field message } order { id token } } } """ variables = { "checkoutId": Node.to_global_id("Checkout", checkout_with_charged_payment.pk), "redirectUrl": "https://www.example.com", } get_graphql_content(api_client.post_graphql(query, variables))
def mutate_and_get_payload(cls, input, info): name = input.get('name') homeworld_id = input.get('homeworld_id') try: homeworld_id = int(homeworld_id) except ValueError: try: _type, homeworld_id = Node.from_global_id(homeworld_id) assert _type == 'planet', 'The homeworld should be a Planet, but found {}'.format(resolved.type) except: raise Exception("Received wrong Planet id: {}".format(homeworld_id)) homeworld = Planet._meta.model.objects.get(id=homeworld_id) hero = Hero._meta.model(name=name, homeworld=homeworld) hero.save() return CreateHero(hero=hero, ok=bool(hero.id))