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))
