def test_product_image_create_mutation(admin_api_client, product):
query = """
mutation createProductImage($image: Upload!, $product: ID!) {
productImageCreate(input: {image: $image, product: $product}) {
productImage {
id
image
url
sortOrder
}
}
}
"""
image_file, image_name = create_image()
variables = {
'product': graphene.Node.to_global_id('Product', product.id),
'image': image_name}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = admin_api_client.post_multipart(reverse('api'), body)
content = get_graphql_content(response)
assert 'errors' not in content
data = content['data']['productImageCreate']
file_name = data['productImage']['image']
product.refresh_from_db()
assert product.images.first().image.file
assert product.images.first().image.name == file_name
def digital_content(category, media_root) -> DigitalContent:
product_type = ProductType.objects.create(
name="Digital Type",
has_variants=True,
is_shipping_required=False,
is_digital=True,
)
product = Product.objects.create(
name="Test digital product",
price=Money("10.00", "USD"),
product_type=product_type,
category=category,
)
product_variant = ProductVariant.objects.create(
product=product,
sku="SKU_554",
cost_price=Money(1, "USD"),
quantity=5,
quantity_allocated=3,
)
assert product_variant.is_digital()
image_file, image_name = create_image()
d_content = DigitalContent.objects.create(
content_file=image_file,
product_variant=product_variant,
use_default_settings=True,
)
return d_content
def test_create_collection(admin_api_client, product_list):
query = """
mutation createCollection(
$name: String!, $slug: String!, $products: [ID], $backgroundImage: Upload!, $isPublished: Boolean!) {
collectionCreate(
input: {name: $name, slug: $slug, products: $products, backgroundImage: $backgroundImage, isPublished: $isPublished}) {
collection {
name
slug
products {
totalCount
}
}
}
}
"""
product_ids = [
to_global_id('Product', product.pk) for product in product_list]
image_file, image_name = create_image()
name = 'test-name'
slug = 'test-slug'
variables = {
'name': name, 'slug': slug, 'products': product_ids,
'backgroundImage': image_name, 'isPublished': True}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = admin_api_client.post_multipart(reverse('api'), body)
content = get_graphql_content(response)
assert 'errors' not in content
data = content['data']['collectionCreate']['collection']
assert data['name'] == name
assert data['slug'] == slug
assert data['products']['totalCount'] == len(product_ids)
collection = Collection.objects.get(slug=slug)
assert collection.background_image.file
def test_create_collection(admin_api_client, product_list):
query = """
mutation createCollection(
$name: String!, $slug: String!, $products: [ID], $backgroundImage: Upload!, $isPublished: Boolean!) {
collectionCreate(
input: {name: $name, slug: $slug, products: $products, backgroundImage: $backgroundImage, isPublished: $isPublished}) {
collection {
name
slug
products {
totalCount
}
}
}
}
"""
product_ids = [
to_global_id('Product', product.pk) for product in product_list]
image_file, image_name = create_image()
name = 'test-name'
slug = 'test-slug'
variables = {
'name': name, 'slug': slug, 'products': product_ids,
'backgroundImage': image_name, 'isPublished': True}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = admin_api_client.post_multipart(reverse('api'), body)
content = get_graphql_content(response)
assert 'errors' not in content
data = content['data']['collectionCreate']['collection']
assert data['name'] == name
assert data['slug'] == slug
assert data['products']['totalCount'] == len(product_ids)
collection = Collection.objects.get(slug=slug)
assert collection.background_image.file
def test_digital_content_create_mutation_default_settings(
monkeypatch, staff_api_client, variant, permission_manage_products):
query = """
mutation digitalCreate($variant: ID!,
$input: DigitalContentUploadInput!) {
digitalContentCreate(variantId: $variant, input: $input) {
variant {
id
}
}
}
"""
image_file, image_name = create_image()
variables = {
'variant': graphene.Node.to_global_id('ProductVariant', variant.id),
'input': {
'useDefaultSettings': True,
'contentFile': image_name
}
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
get_graphql_content(response)
variant.refresh_from_db()
assert variant.digital_content.content_file
assert variant.digital_content.use_default_settings
def test_product_image_create_mutation(monkeypatch, staff_api_client, product,
permission_manage_products):
query = """
mutation createProductImage($image: Upload!, $product: ID!) {
productImageCreate(input: {image: $image, product: $product}) {
image {
id
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(('saleor.graphql.product.mutations.products.'
'create_product_thumbnails.delay'),
mock_create_thumbnails)
image_file, image_name = create_image()
variables = {
'product': graphene.Node.to_global_id('Product', product.id),
'image': image_name
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
get_graphql_content(response)
product.refresh_from_db()
product_image = product.images.last()
assert product_image.image.file
# The image creation should have triggered a warm-up
mock_create_thumbnails.assert_called_once_with(product_image.pk)
def test_digital_content_create_mutation_removes_old_content(
monkeypatch, staff_api_client, variant, permission_manage_products):
query = """
mutation digitalCreate($variant: ID!,
$input: DigitalContentUploadInput!) {
digitalContentCreate(variantId: $variant, input: $input) {
variant {
id
}
}
}
"""
image_file, image_name = create_image()
d_content = DigitalContent.objects.create(
content_file=image_file, product_variant=variant,
use_default_settings=True)
variables = {
'variant': graphene.Node.to_global_id('ProductVariant', variant.id),
'input': {
'useDefaultSettings': True,
'contentFile': image_name
}
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
get_graphql_content(response)
variant.refresh_from_db()
assert variant.digital_content.content_file
assert variant.digital_content.use_default_settings
assert not DigitalContent.objects.filter(id=d_content.id).exists()
def test_delete_image(client):
user = f.create_user(email='*****@*****.**', password='******')
client.login(user=user)
url = reverse('posts-list')
post = {
'text': 'Announcement!',
'posted_at': 'fb',
'scheduled_time': '2018-10-09T18:30:00Z'
}
response = client.json.post(url, json.dumps(post))
assert response.status_code == 201
post_id = response.data['id']
# Delete image before uploading
url = reverse('posts-delete-image', kwargs={'pk': post_id})
response = client.post(url)
assert response.status_code == 400
image = u.create_image(None, 'avatar.png')
image = SimpleUploadedFile('front.png', image.getvalue())
url = reverse('posts-upload-image', kwargs={'pk': post_id})
response = client.post(url, {'image': image}, format='multipart')
assert response.status_code == 200
assert response.data["image"] is not None
url = reverse('posts-delete-image', kwargs={'pk': post_id})
response = client.post(url)
assert response.status_code == 200
assert response.data["image"] is None
def test_product_image_create_mutation(admin_api_client, product):
query = """
mutation createProductImage($image: Upload!, $product: ID!) {
productImageCreate(input: {image: $image, product: $product}) {
productImage {
id
image
url
sortOrder
}
}
}
"""
image_file, image_name = create_image()
variables = {
'product': graphene.Node.to_global_id('Product', product.id),
'image': image_name
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = admin_api_client.post_multipart(reverse('api'), body)
content = get_graphql_content(response)
assert 'errors' not in content
data = content['data']['productImageCreate']
file_name = data['productImage']['image']
product.refresh_from_db()
assert product.images.first().image.file
assert product.images.first().image.name == file_name
def test_update_collection_with_background_image(
monkeypatch, staff_api_client, collection, permission_manage_products):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.collection.forms.'
'create_collection_background_image_thumbnails.delay'),
mock_create_thumbnails)
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
variables = {
'name': 'new-name',
'slug': 'new-slug',
'id': to_global_id('Collection', collection.id),
'backgroundImage': image_name,
'backgroundImageAlt': image_alt,
'isPublished': True}
body = get_multipart_request_body(
MUTATION_UPDATE_COLLECTION_WITH_BACKGROUND_IMAGE, variables,
image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['collectionUpdate']
assert not data['errors']
slug = data['collection']['slug']
collection = Collection.objects.get(slug=slug)
assert collection.background_image
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data['collection']['backgroundImage']['alt'] == image_alt
def test_category_image_query(user_api_client, non_default_category):
category = non_default_category
image_file, image_name = create_image()
category.background_image = image_file
category.save()
category_id = graphene.Node.to_global_id('Category', category.pk)
query = """
query fetchCategory($id: ID!){
category(id: $id) {
backgroundImage {
url(size: 120)
}
}
}
"""
variables = json.dumps({'id': category_id})
response = user_api_client.post(reverse('api'), {
'query': query,
'variables': variables
})
content = get_graphql_content(response)
assert 'errors' not in content
data = content['data']['category']
thumbnail_url = category.background_image.thumbnail['120x120'].url
assert data['backgroundImage']['url'] == thumbnail_url
def test_digital_content_create_mutation_default_settings(
monkeypatch, staff_api_client, variant, permission_manage_products,
media_root):
query = """
mutation digitalCreate($variant: ID!,
$input: DigitalContentUploadInput!) {
digitalContentCreate(variantId: $variant, input: $input) {
variant {
id
}
}
}
"""
image_file, image_name = create_image()
variables = {
"variant": graphene.Node.to_global_id("ProductVariant", variant.id),
"input": {
"useDefaultSettings": True,
"contentFile": image_name
},
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
get_graphql_content(response)
variant.refresh_from_db()
assert variant.digital_content.content_file
assert variant.digital_content.use_default_settings
def test_fulfill_digital_lines(
mock_digital_settings, mock_email_fulfillment, order_with_lines, media_root
):
mock_digital_settings.return_value = {"automatic_fulfillment": True}
line = order_with_lines.lines.all()[0]
image_file, image_name = create_image()
variant = line.variant
digital_content = DigitalContent.objects.create(
content_file=image_file, product_variant=variant, use_default_settings=True
)
line.variant.digital_content = digital_content
line.is_shipping_required = False
line.save()
order_with_lines.refresh_from_db()
automatically_fulfill_digital_lines(order_with_lines)
line.refresh_from_db()
fulfillment = Fulfillment.objects.get(order=order_with_lines)
fulfillment_lines = fulfillment.lines.all()
assert fulfillment_lines.count() == 1
assert line.digital_content_url
assert mock_email_fulfillment.delay.called
def test_fulfill_digital_lines(
mock_digital_settings, mock_email_fulfillment, order_with_lines, media_root
):
mock_digital_settings.return_value = {"automatic_fulfillment": True}
line = order_with_lines.lines.all()[0]
image_file, image_name = create_image()
variant = line.variant
digital_content = DigitalContent.objects.create(
content_file=image_file, product_variant=variant, use_default_settings=True
)
line.variant.digital_content = digital_content
line.is_shipping_required = False
line.save()
order_with_lines.refresh_from_db()
automatically_fulfill_digital_lines(order_with_lines)
line.refresh_from_db()
fulfillment = Fulfillment.objects.get(order=order_with_lines)
fulfillment_lines = fulfillment.lines.all()
assert fulfillment_lines.count() == 1
assert line.digital_content_url
assert mock_email_fulfillment.delay.called
def test_update_collection_with_background_image(
monkeypatch, staff_api_client, collection, permission_manage_products,
media_root):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.collection.forms.'
'create_collection_background_image_thumbnails.delay'),
mock_create_thumbnails)
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
variables = {
'name': 'new-name',
'slug': 'new-slug',
'id': to_global_id('Collection', collection.id),
'backgroundImage': image_name,
'backgroundImageAlt': image_alt,
'isPublished': True}
body = get_multipart_request_body(
MUTATION_UPDATE_COLLECTION_WITH_BACKGROUND_IMAGE, variables,
image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['collectionUpdate']
assert not data['errors']
slug = data['collection']['slug']
collection = Collection.objects.get(slug=slug)
assert collection.background_image
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data['collection']['backgroundImage']['alt'] == image_alt
def test_category_update_mutation(staff_api_client, category,
permission_manage_products):
query = """
mutation($id: ID!, $name: String, $slug: String, $backgroundImage: Upload, $description: String) {
categoryUpdate(
id: $id
input: {
name: $name
description: $description
backgroundImage: $backgroundImage
slug: $slug
}
) {
category {
id
name
description
parent {
id
}
}
errors {
field
message
}
}
}
"""
# create child category and test that the update mutation won't change
# it's parent
child_category = category.children.create(name='child')
category_name = 'Updated name'
category_slug = slugify(category_name)
category_description = 'Updated description'
image_file, image_name = create_image()
category_id = graphene.Node.to_global_id('Category', child_category.pk)
variables = {
'name': category_name,
'description': category_description,
'backgroundImage': image_name,
'id': category_id,
'slug': category_slug
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['categoryUpdate']
assert data['errors'] == []
assert data['category']['id'] == category_id
assert data['category']['name'] == category_name
assert data['category']['description'] == category_description
parent_id = graphene.Node.to_global_id('Category', category.pk)
assert data['category']['parent']['id'] == parent_id
category = Category.objects.get(name=category_name)
assert category.background_image.file
def test_create_collection(monkeypatch, staff_api_client, product_list,
permission_manage_products):
query = """
mutation createCollection(
$name: String!, $slug: String!, $description: String, $products: [ID], $backgroundImage: Upload!, $backgroundImageAlt: String, $isPublished: Boolean!) {
collectionCreate(
input: {name: $name, slug: $slug, description: $description, products: $products, backgroundImage: $backgroundImage, backgroundImageAlt: $backgroundImageAlt, isPublished: $isPublished}) {
collection {
name
slug
description
products {
totalCount
}
backgroundImage{
alt
}
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.collection.forms.'
'create_collection_background_image_thumbnails.delay'),
mock_create_thumbnails)
product_ids = [
to_global_id('Product', product.pk) for product in product_list
]
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
name = 'test-name'
slug = 'test-slug'
description = 'test-description'
variables = {
'name': name,
'slug': slug,
'description': description,
'products': product_ids,
'backgroundImage': image_name,
'backgroundImageAlt': image_alt,
'isPublished': True
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['collectionCreate']['collection']
assert data['name'] == name
assert data['slug'] == slug
assert data['description'] == description
assert data['products']['totalCount'] == len(product_ids)
collection = Collection.objects.get(slug=slug)
assert collection.background_image.file
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data['backgroundImage']['alt'] == image_alt
def test_warmer(product_in_stock, product_type):
Category.objects.create(name='b', slug='b')
category = Category.objects.create(name='c', slug='c', image=create_image()[0])
product = Product.objects.create(name='b', price=Decimal('1.00'), product_type=product_type, category=category)
product_warmer = ProductWarmer.all()
category_warmer = CategoryWarmer.all()
assert category_warmer._wrapper.query_set.count() == 3
assert product_warmer._wrapper.query_set.count() == 0
assert category_warmer() == 1 * len(CATEGORY_IMAGE_SETS)
assert product_warmer() == 0
for i in range(1, 3):
ProductImage.objects.create(product=product, image=create_image()[0])
assert ProductWarmer.all()._wrapper.query_set.count() == i
assert ProductWarmer.all()() == len(PRODUCT_IMAGE_SETS)
def test_update_collection_with_background_image(monkeypatch, staff_api_client,
collection,
permission_manage_products):
query = """
mutation updateCollection(
$name: String!, $slug: String!, $id: ID!, $backgroundImage: Upload, $backgroundImageAlt: String, $isPublished: Boolean!) {
collectionUpdate(
id: $id, input: {
name: $name,
slug: $slug,
backgroundImage: $backgroundImage,
backgroundImageAlt: $backgroundImageAlt,
isPublished: $isPublished
}
) {
collection {
slug
backgroundImage{
alt
}
}
errors {
field
message
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.collection.forms.'
'create_collection_background_image_thumbnails.delay'),
mock_create_thumbnails)
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
variables = {
'name': 'new-name',
'slug': 'new-slug',
'id': to_global_id('Collection', collection.id),
'backgroundImage': image_name,
'backgroundImageAlt': image_alt,
'isPublished': True
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['collectionUpdate']
assert not data['errors']
slug = data['collection']['slug']
collection = Collection.objects.get(slug=slug)
assert collection.background_image
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data['collection']['backgroundImage']['alt'] == image_alt
def test_category_image_query(user_api_client, non_default_category):
category = non_default_category
image_file, image_name = create_image()
category.background_image = image_file
category.save()
category_id = graphene.Node.to_global_id('Category', category.pk)
variables = {'id': category_id}
response = user_api_client.post_graphql(FETCH_CATEGORY_QUERY, variables)
content = get_graphql_content(response)
data = content['data']['category']
thumbnail_url = category.background_image.thumbnail['120x120'].url
assert thumbnail_url in data['backgroundImage']['url']
def test_collection_image_query(user_api_client, collection):
alt_text = 'Alt text for an image.'
image_file, image_name = create_image()
collection.background_image = image_file
collection.background_image_alt = alt_text
collection.save()
collection_id = graphene.Node.to_global_id('Collection', collection.pk)
variables = {'id': collection_id}
response = user_api_client.post_graphql(FETCH_COLLECTION_QUERY, variables)
content = get_graphql_content(response)
data = content['data']['collection']
thumbnail_url = collection.background_image.thumbnail['120x120'].url
assert thumbnail_url in data['backgroundImage']['url']
assert data['backgroundImage']['alt'] == alt_text
def test_collection_image_query(user_api_client, collection, media_root):
alt_text = 'Alt text for an image.'
image_file, image_name = create_image()
collection.background_image = image_file
collection.background_image_alt = alt_text
collection.save()
collection_id = graphene.Node.to_global_id('Collection', collection.pk)
variables = {'id': collection_id}
response = user_api_client.post_graphql(FETCH_COLLECTION_QUERY, variables)
content = get_graphql_content(response)
data = content['data']['collection']
thumbnail_url = collection.background_image.thumbnail['120x120'].url
assert thumbnail_url in data['backgroundImage']['url']
assert data['backgroundImage']['alt'] == alt_text
def test_collection_image_query(user_api_client, collection, media_root):
alt_text = "Alt text for an image."
image_file, image_name = create_image()
collection.background_image = image_file
collection.background_image_alt = alt_text
collection.save()
collection_id = graphene.Node.to_global_id("Collection", collection.pk)
variables = {"id": collection_id}
response = user_api_client.post_graphql(FETCH_COLLECTION_QUERY, variables)
content = get_graphql_content(response)
data = content["data"]["collection"]
thumbnail_url = collection.background_image.thumbnail["120x120"].url
assert thumbnail_url in data["backgroundImage"]["url"]
assert data["backgroundImage"]["alt"] == alt_text
def test_collection_image_query(user_api_client, collection, media_root):
alt_text = "Alt text for an image."
image_file, image_name = create_image()
collection.background_image = image_file
collection.background_image_alt = alt_text
collection.save()
collection_id = graphene.Node.to_global_id("Collection", collection.pk)
variables = {"id": collection_id}
response = user_api_client.post_graphql(FETCH_COLLECTION_QUERY, variables)
content = get_graphql_content(response)
data = content["data"]["collection"]
thumbnail_url = collection.background_image.thumbnail["120x120"].url
assert thumbnail_url in data["backgroundImage"]["url"]
assert data["backgroundImage"]["alt"] == alt_text
def test_category_update_mutation(
monkeypatch, staff_api_client, category, permission_manage_products, media_root
):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.product.thumbnails."
"create_category_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
# create child category and test that the update mutation won't change
# it's parent
child_category = category.children.create(name="child")
category_name = "Updated name"
category_slug = slugify(category_name)
category_description = "Updated description"
image_file, image_name = create_image()
image_alt = "Alt text for an image."
category_id = graphene.Node.to_global_id("Category", child_category.pk)
variables = {
"name": category_name,
"description": category_description,
"backgroundImage": image_name,
"backgroundImageAlt": image_alt,
"id": category_id,
"slug": category_slug,
}
body = get_multipart_request_body(
MUTATION_CATEGORY_UPDATE_MUTATION, variables, image_file, image_name
)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products]
)
content = get_graphql_content(response)
data = content["data"]["categoryUpdate"]
assert data["errors"] == []
assert data["category"]["id"] == category_id
assert data["category"]["name"] == category_name
assert data["category"]["description"] == category_description
parent_id = graphene.Node.to_global_id("Category", category.pk)
assert data["category"]["parent"]["id"] == parent_id
category = Category.objects.get(name=category_name)
assert category.background_image.file
mock_create_thumbnails.assert_called_once_with(category.pk)
assert data["category"]["backgroundImage"]["alt"] == image_alt
def test_category_update_mutation(
monkeypatch, staff_api_client, category, permission_manage_products, media_root
):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.dashboard.category.forms."
"create_category_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
# create child category and test that the update mutation won't change
# it's parent
child_category = category.children.create(name="child")
category_name = "Updated name"
category_slug = slugify(category_name)
category_description = "Updated description"
image_file, image_name = create_image()
image_alt = "Alt text for an image."
category_id = graphene.Node.to_global_id("Category", child_category.pk)
variables = {
"name": category_name,
"description": category_description,
"backgroundImage": image_name,
"backgroundImageAlt": image_alt,
"id": category_id,
"slug": category_slug,
}
body = get_multipart_request_body(
MUTATION_CATEGORY_UPDATE_MUTATION, variables, image_file, image_name
)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products]
)
content = get_graphql_content(response)
data = content["data"]["categoryUpdate"]
assert data["errors"] == []
assert data["category"]["id"] == category_id
assert data["category"]["name"] == category_name
assert data["category"]["description"] == category_description
parent_id = graphene.Node.to_global_id("Category", category.pk)
assert data["category"]["parent"]["id"] == parent_id
category = Category.objects.get(name=category_name)
assert category.background_image.file
mock_create_thumbnails.assert_called_once_with(category.pk)
assert data["category"]["backgroundImage"]["alt"] == image_alt
def test_category_image_query(user_api_client, non_default_category, media_root):
alt_text = "Alt text for an image."
category = non_default_category
image_file, image_name = create_image()
category.background_image = image_file
category.background_image_alt = alt_text
category.save()
category_id = graphene.Node.to_global_id("Category", category.pk)
variables = {"id": category_id}
response = user_api_client.post_graphql(FETCH_CATEGORY_QUERY, variables)
content = get_graphql_content(response)
data = content["data"]["category"]
thumbnail_url = category.background_image.thumbnail["120x120"].url
assert thumbnail_url in data["backgroundImage"]["url"]
assert data["backgroundImage"]["alt"] == alt_text
def test_category_image_query(user_api_client, non_default_category, media_root):
alt_text = "Alt text for an image."
category = non_default_category
image_file, image_name = create_image()
category.background_image = image_file
category.background_image_alt = alt_text
category.save()
category_id = graphene.Node.to_global_id("Category", category.pk)
variables = {"id": category_id}
response = user_api_client.post_graphql(FETCH_CATEGORY_QUERY, variables)
content = get_graphql_content(response)
data = content["data"]["category"]
thumbnail_url = category.background_image.thumbnail["120x120"].url
assert thumbnail_url in data["backgroundImage"]["url"]
assert data["backgroundImage"]["alt"] == alt_text
def test_category_image_query(user_api_client, non_default_category):
alt_text = 'Alt text for an image.'
category = non_default_category
image_file, image_name = create_image()
category.background_image = image_file
category.background_image_alt = alt_text
category.save()
category_id = graphene.Node.to_global_id('Category', category.pk)
variables = {'id': category_id}
response = user_api_client.post_graphql(FETCH_CATEGORY_QUERY, variables)
content = get_graphql_content(response)
data = content['data']['category']
thumbnail_url = category.background_image.thumbnail['120x120'].url
assert thumbnail_url in data['backgroundImage']['url']
assert data['backgroundImage']['alt'] == alt_text
def test_category_add_with_background_image(monkeypatch, admin_client):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
url = reverse('dashboard:category-add')
image, image_name = create_image()
data = {
'name': 'Cars',
'description': 'Super fast!',
'background_image': image}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
mock_create_thumbnails.assert_called_once_with(Category.objects.last().pk)
def test_category_add_with_background_image(monkeypatch, admin_client, media_root):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.dashboard.category.forms."
"create_category_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
url = reverse("dashboard:category-add")
image, image_name = create_image()
data = {"name": "Cars", "description": "Super fast!", "background_image": image}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
mock_create_thumbnails.assert_called_once_with(Category.objects.last().pk)
def test_category_add_with_background_image(monkeypatch, admin_client):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(('remote_works.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
url = reverse('dashboard:category-add')
image, image_name = create_image()
data = {
'name': 'Cars',
'description': 'Super fast!',
'background_image': image
}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
mock_create_thumbnails.assert_called_once_with(Category.objects.last().pk)
def digital_content(category):
product_type = ProductType.objects.create(
name='Digital Type', has_variants=True, is_shipping_required=False,
is_digital=True
)
product = Product.objects.create(
name='Test digital product', price=Money('10.00', 'USD'),
product_type=product_type, category=category)
product_variant = ProductVariant.objects.create(
product=product, sku='SKU_554', cost_price=Money(1, 'USD'), quantity=5,
quantity_allocated=3)
image_file, image_name = create_image()
d_content = DigitalContent.objects.create(
content_file=image_file, product_variant=product_variant,
use_default_settings=True)
return d_content
def test_category_update_mutation(monkeypatch, staff_api_client, category,
permission_manage_products):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(('saleor.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
# create child category and test that the update mutation won't change
# it's parent
child_category = category.children.create(name='child')
category_name = 'Updated name'
category_slug = slugify(category_name)
category_description = 'Updated description'
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
category_id = graphene.Node.to_global_id('Category', child_category.pk)
variables = {
'name': category_name,
'description': category_description,
'backgroundImage': image_name,
'backgroundImageAlt': image_alt,
'id': category_id,
'slug': category_slug
}
body = get_multipart_request_body(MUTATION_CATEGORY_UPDATE_MUTATION,
variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['categoryUpdate']
assert data['errors'] == []
assert data['category']['id'] == category_id
assert data['category']['name'] == category_name
assert data['category']['description'] == category_description
parent_id = graphene.Node.to_global_id('Category', category.pk)
assert data['category']['parent']['id'] == parent_id
category = Category.objects.get(name=category_name)
assert category.background_image.file
mock_create_thumbnails.assert_called_once_with(category.pk)
assert data['category']['backgroundImage']['alt'] == image_alt
def digital_content(category, media_root):
product_type = ProductType.objects.create(
name='Digital Type', has_variants=True, is_shipping_required=False,
is_digital=True
)
product = Product.objects.create(
name='Test digital product', price=Money('10.00', 'USD'),
product_type=product_type, category=category)
product_variant = ProductVariant.objects.create(
product=product, sku='SKU_554', cost_price=Money(1, 'USD'), quantity=5,
quantity_allocated=3)
assert product_variant.is_digital()
image_file, image_name = create_image()
d_content = DigitalContent.objects.create(
content_file=image_file, product_variant=product_variant,
use_default_settings=True)
return d_content
def test_category_edit_with_background_image(
monkeypatch, admin_client, category):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
url = reverse('dashboard:category-edit', kwargs={'root_pk': category.pk})
image, image_name = create_image()
data = {
'name': 'Cars',
'description': 'Super fast!',
'background_image': image}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
category.refresh_from_db()
assert category.background_image
mock_create_thumbnails.assert_called_once_with(category.pk)
def test_category_add_with_background_image(monkeypatch, admin_client,
media_root):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
("saleor.dashboard.category.forms."
"create_category_background_image_thumbnails.delay"),
mock_create_thumbnails,
)
url = reverse("dashboard:category-add")
image, image_name = create_image()
data = {
"name": "Cars",
"description": "Super fast!",
"background_image": image
}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
mock_create_thumbnails.assert_called_once_with(Category.objects.last().pk)
def test_collection_image_query(user_api_client, collection):
image_file, image_name = create_image()
collection.background_image = image_file
collection.save()
collection_id = graphene.Node.to_global_id('Collection', collection.pk)
query = """
query fetchCollection($id: ID!){
collection(id: $id) {
backgroundImage {
url(size: 120)
}
}
}
"""
variables = {'id': collection_id}
response = user_api_client.post_graphql(query, variables)
content = get_graphql_content(response)
data = content['data']['collection']
thumbnail_url = collection.background_image.thumbnail['120x120'].url
assert data['backgroundImage']['url'] == thumbnail_url
def test_category_edit_with_background_image(monkeypatch, admin_client,
category):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(('remote_works.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
url = reverse('dashboard:category-edit', kwargs={'root_pk': category.pk})
image, image_name = create_image()
data = {
'name': 'Cars',
'description': 'Super fast!',
'background_image': image
}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
category.refresh_from_db()
assert category.background_image
mock_create_thumbnails.assert_called_once_with(category.pk)
def test_category_edit_with_background_image(
monkeypatch, admin_client, category, media_root
):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.dashboard.category.forms."
"create_category_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
url = reverse("dashboard:category-edit", kwargs={"root_pk": category.pk})
image, image_name = create_image()
data = {"name": "Cars", "description": "Super fast!", "background_image": image}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
category.refresh_from_db()
assert category.background_image
mock_create_thumbnails.assert_called_once_with(category.pk)
def test_category_update_mutation(
monkeypatch, staff_api_client, category, permission_manage_products):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
# create child category and test that the update mutation won't change
# it's parent
child_category = category.children.create(name='child')
category_name = 'Updated name'
category_slug = slugify(category_name)
category_description = 'Updated description'
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
category_id = graphene.Node.to_global_id('Category', child_category.pk)
variables = {
'name': category_name, 'description': category_description,
'backgroundImage': image_name, 'backgroundImageAlt': image_alt,
'id': category_id, 'slug': category_slug}
body = get_multipart_request_body(
MUTATION_CATEGORY_UPDATE_MUTATION, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['categoryUpdate']
assert data['errors'] == []
assert data['category']['id'] == category_id
assert data['category']['name'] == category_name
assert data['category']['description'] == category_description
parent_id = graphene.Node.to_global_id('Category', category.pk)
assert data['category']['parent']['id'] == parent_id
category = Category.objects.get(name=category_name)
assert category.background_image.file
mock_create_thumbnails.assert_called_once_with(category.pk)
assert data['category']['backgroundImage']['alt'] == image_alt
def test_collection_image_query(user_api_client, collection):
image_file, image_name = create_image()
collection.background_image = image_file
collection.save()
collection_id = graphene.Node.to_global_id('Collection', collection.pk)
query = """
query fetchCollection($id: ID!){
collection(id: $id) {
backgroundImage {
url(size: 120)
}
}
}
"""
variables = json.dumps({'id': collection_id})
response = user_api_client.post(
reverse('api'), {'query': query, 'variables': variables})
content = get_graphql_content(response)
assert 'errors' not in content
data = content['data']['collection']
thumbnail_url = collection.background_image.thumbnail['120x120'].url
assert data['backgroundImage']['url'] == thumbnail_url
def test_update_collection_with_background_image(
monkeypatch, staff_api_client, collection, permission_manage_products, media_root
):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.dashboard.collection.forms."
"create_collection_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
image_file, image_name = create_image()
image_alt = "Alt text for an image."
variables = {
"name": "new-name",
"slug": "new-slug",
"id": to_global_id("Collection", collection.id),
"backgroundImage": image_name,
"backgroundImageAlt": image_alt,
"isPublished": True,
}
body = get_multipart_request_body(
MUTATION_UPDATE_COLLECTION_WITH_BACKGROUND_IMAGE,
variables,
image_file,
image_name,
)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products]
)
content = get_graphql_content(response)
data = content["data"]["collectionUpdate"]
assert not data["errors"]
slug = data["collection"]["slug"]
collection = Collection.objects.get(slug=slug)
assert collection.background_image
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data["collection"]["backgroundImage"]["alt"] == image_alt
def test_digital_content_create_mutation_custom_settings(
monkeypatch, staff_api_client, variant, permission_manage_products,
media_root):
query = """
mutation createDigitalContent($variant: ID!,
$input: DigitalContentUploadInput!) {
digitalContentCreate(variantId: $variant, input: $input) {
variant {
id
}
}
}
"""
image_file, image_name = create_image()
url_valid_days = 3
max_downloads = 5
variables = {
"variant": graphene.Node.to_global_id("ProductVariant", variant.id),
"input": {
"useDefaultSettings": False,
"maxDownloads": max_downloads,
"urlValidDays": url_valid_days,
"automaticFulfillment": True,
"contentFile": image_name,
},
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
get_graphql_content(response)
variant.refresh_from_db()
assert variant.digital_content.content_file
assert variant.digital_content.max_downloads == max_downloads
assert variant.digital_content.url_valid_days == url_valid_days
assert variant.digital_content.automatic_fulfillment
assert not variant.digital_content.use_default_settings
def test_category_edit_with_background_image(monkeypatch, admin_client,
category, media_root):
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
("saleor.dashboard.category.forms."
"create_category_background_image_thumbnails.delay"),
mock_create_thumbnails,
)
url = reverse("dashboard:category-edit", kwargs={"root_pk": category.pk})
image, image_name = create_image()
data = {
"name": "Cars",
"description": "Super fast!",
"background_image": image
}
response = admin_client.post(url, data, follow=True)
assert response.status_code == 200
category.refresh_from_db()
assert category.background_image
mock_create_thumbnails.assert_called_once_with(category.pk)
def test_product_image_create_mutation(staff_api_client, product,
permission_manage_products):
query = """
mutation createProductImage($image: Upload!, $product: ID!) {
productImageCreate(input: {image: $image, product: $product}) {
image {
id
}
}
}
"""
image_file, image_name = create_image()
variables = {
'product': graphene.Node.to_global_id('Product', product.id),
'image': image_name
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
product.refresh_from_db()
assert product.images.first().image.file
def test_digital_content_create_mutation_custom_settings(
monkeypatch, staff_api_client, variant, permission_manage_products):
query = """
mutation createDigitalContent($variant: ID!,
$input: DigitalContentUploadInput!) {
digitalContentCreate(variantId: $variant, input: $input) {
variant {
id
}
}
}
"""
image_file, image_name = create_image()
url_valid_days = 3
max_downloads = 5
variables = {
'variant': graphene.Node.to_global_id('ProductVariant', variant.id),
'input': {
'useDefaultSettings': False,
'maxDownloads': max_downloads,
'urlValidDays': url_valid_days,
'automaticFulfillment': True,
'contentFile': image_name
}
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
get_graphql_content(response)
variant.refresh_from_db()
assert variant.digital_content.content_file
assert variant.digital_content.max_downloads == max_downloads
assert variant.digital_content.url_valid_days == url_valid_days
assert variant.digital_content.automatic_fulfillment
assert not variant.digital_content.use_default_settings
def test_create_collection(monkeypatch, staff_api_client, product_list,
media_root, permission_manage_products):
query = """
mutation createCollection(
$name: String!, $slug: String!, $description: String,
$descriptionJson: JSONString, $products: [ID],
$backgroundImage: Upload!, $backgroundImageAlt: String,
$isPublished: Boolean!, $publicationDate: Date) {
collectionCreate(
input: {
name: $name,
slug: $slug,
description: $description,
descriptionJson: $descriptionJson,
products: $products,
backgroundImage: $backgroundImage,
backgroundImageAlt: $backgroundImageAlt,
isPublished: $isPublished,
publicationDate: $publicationDate}) {
collection {
name
slug
description
descriptionJson
products {
totalCount
}
publicationDate
backgroundImage{
alt
}
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
("saleor.dashboard.collection.forms."
"create_collection_background_image_thumbnails.delay"),
mock_create_thumbnails,
)
product_ids = [
to_global_id("Product", product.pk) for product in product_list
]
image_file, image_name = create_image()
image_alt = "Alt text for an image."
name = "test-name"
slug = "test-slug"
description = "test-description"
description_json = json.dumps({"content": "description"})
publication_date = date.today()
variables = {
"name": name,
"slug": slug,
"description": description,
"descriptionJson": description_json,
"products": product_ids,
"backgroundImage": image_name,
"backgroundImageAlt": image_alt,
"isPublished": True,
"publicationDate": publication_date,
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content["data"]["collectionCreate"]["collection"]
assert data["name"] == name
assert data["slug"] == slug
assert data["description"] == description
assert data["descriptionJson"] == description_json
assert data["publicationDate"] == publication_date.isoformat()
assert data["products"]["totalCount"] == len(product_ids)
collection = Collection.objects.get(slug=slug)
assert collection.background_image.file
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data["backgroundImage"]["alt"] == image_alt
def test_category_create_mutation(
monkeypatch, staff_api_client, permission_manage_products):
query = """
mutation(
$name: String, $slug: String, $description: String,
$descriptionJson: JSONString, $backgroundImage: Upload,
$backgroundImageAlt: String, $parentId: ID) {
categoryCreate(
input: {
name: $name
slug: $slug
description: $description
descriptionJson: $descriptionJson
backgroundImage: $backgroundImage
backgroundImageAlt: $backgroundImageAlt
},
parent: $parentId
) {
category {
id
name
slug
description
descriptionJson
parent {
name
id
}
backgroundImage{
alt
}
}
errors {
field
message
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.category.forms.'
'create_category_background_image_thumbnails.delay'),
mock_create_thumbnails)
category_name = 'Test category'
category_slug = slugify(category_name)
category_description = 'Test description'
category_description_json = json.dumps({'content': 'description'})
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
# test creating root category
variables = {
'name': category_name, 'description': category_description,
'descriptionJson': category_description_json,
'backgroundImage': image_name, 'backgroundImageAlt': image_alt,
'slug': category_slug}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['categoryCreate']
assert data['errors'] == []
assert data['category']['name'] == category_name
assert data['category']['description'] == category_description
assert data['category']['descriptionJson'] == category_description_json
assert not data['category']['parent']
category = Category.objects.get(name=category_name)
assert category.background_image.file
mock_create_thumbnails.assert_called_once_with(category.pk)
assert data['category']['backgroundImage']['alt'] == image_alt
# test creating subcategory
parent_id = data['category']['id']
variables = {
'name': category_name, 'description': category_description,
'parentId': parent_id, 'slug': category_slug}
response = staff_api_client.post_graphql(query, variables)
content = get_graphql_content(response)
data = content['data']['categoryCreate']
assert data['errors'] == []
assert data['category']['parent']['id'] == parent_id
def test_create_collection(
monkeypatch, staff_api_client, product_list, permission_manage_products):
query = """
mutation createCollection(
$name: String!, $slug: String!, $description: String,
$descriptionJson: JSONString, $products: [ID],
$backgroundImage: Upload!, $backgroundImageAlt: String,
$isPublished: Boolean!, $publicationDate: Date) {
collectionCreate(
input: {
name: $name,
slug: $slug,
description: $description,
descriptionJson: $descriptionJson,
products: $products,
backgroundImage: $backgroundImage,
backgroundImageAlt: $backgroundImageAlt,
isPublished: $isPublished,
publicationDate: $publicationDate}) {
collection {
name
slug
description
descriptionJson
products {
totalCount
}
publicationDate
backgroundImage{
alt
}
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
('saleor.dashboard.collection.forms.'
'create_collection_background_image_thumbnails.delay'),
mock_create_thumbnails)
product_ids = [
to_global_id('Product', product.pk) for product in product_list]
image_file, image_name = create_image()
image_alt = 'Alt text for an image.'
name = 'test-name'
slug = 'test-slug'
description = 'test-description'
description_json = json.dumps({'content': 'description'})
publication_date = date.today()
variables = {
'name': name, 'slug': slug, 'description': description,
'descriptionJson': description_json, 'products': product_ids,
'backgroundImage': image_name, 'backgroundImageAlt': image_alt,
'isPublished': True, 'publicationDate': publication_date}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products])
content = get_graphql_content(response)
data = content['data']['collectionCreate']['collection']
assert data['name'] == name
assert data['slug'] == slug
assert data['description'] == description
assert data['descriptionJson'] == description_json
assert data['publicationDate'] == publication_date.isoformat()
assert data['products']['totalCount'] == len(product_ids)
collection = Collection.objects.get(slug=slug)
assert collection.background_image.file
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data['backgroundImage']['alt'] == image_alt
def test_create_collection(
monkeypatch, staff_api_client, product_list, media_root, permission_manage_products
):
query = """
mutation createCollection(
$name: String!, $slug: String!, $description: String,
$descriptionJson: JSONString, $products: [ID],
$backgroundImage: Upload!, $backgroundImageAlt: String,
$isPublished: Boolean!, $publicationDate: Date) {
collectionCreate(
input: {
name: $name,
slug: $slug,
description: $description,
descriptionJson: $descriptionJson,
products: $products,
backgroundImage: $backgroundImage,
backgroundImageAlt: $backgroundImageAlt,
isPublished: $isPublished,
publicationDate: $publicationDate}) {
collection {
name
slug
description
descriptionJson
products {
totalCount
}
publicationDate
backgroundImage{
alt
}
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.dashboard.collection.forms."
"create_collection_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
product_ids = [to_global_id("Product", product.pk) for product in product_list]
image_file, image_name = create_image()
image_alt = "Alt text for an image."
name = "test-name"
slug = "test-slug"
description = "test-description"
description_json = json.dumps({"content": "description"})
publication_date = date.today()
variables = {
"name": name,
"slug": slug,
"description": description,
"descriptionJson": description_json,
"products": product_ids,
"backgroundImage": image_name,
"backgroundImageAlt": image_alt,
"isPublished": True,
"publicationDate": publication_date,
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products]
)
content = get_graphql_content(response)
data = content["data"]["collectionCreate"]["collection"]
assert data["name"] == name
assert data["slug"] == slug
assert data["description"] == description
assert data["descriptionJson"] == description_json
assert data["publicationDate"] == publication_date.isoformat()
assert data["products"]["totalCount"] == len(product_ids)
collection = Collection.objects.get(slug=slug)
assert collection.background_image.file
mock_create_thumbnails.assert_called_once_with(collection.pk)
assert data["backgroundImage"]["alt"] == image_alt
def test_category_create_mutation(
monkeypatch, staff_api_client, permission_manage_products, media_root
):
query = """
mutation(
$name: String, $slug: String, $description: String,
$descriptionJson: JSONString, $backgroundImage: Upload,
$backgroundImageAlt: String, $parentId: ID) {
categoryCreate(
input: {
name: $name
slug: $slug
description: $description
descriptionJson: $descriptionJson
backgroundImage: $backgroundImage
backgroundImageAlt: $backgroundImageAlt
},
parent: $parentId
) {
category {
id
name
slug
description
descriptionJson
parent {
name
id
}
backgroundImage{
alt
}
}
errors {
field
message
}
}
}
"""
mock_create_thumbnails = Mock(return_value=None)
monkeypatch.setattr(
(
"saleor.dashboard.category.forms."
"create_category_background_image_thumbnails.delay"
),
mock_create_thumbnails,
)
category_name = "Test category"
category_slug = slugify(category_name)
category_description = "Test description"
category_description_json = json.dumps({"content": "description"})
image_file, image_name = create_image()
image_alt = "Alt text for an image."
# test creating root category
variables = {
"name": category_name,
"description": category_description,
"descriptionJson": category_description_json,
"backgroundImage": image_name,
"backgroundImageAlt": image_alt,
"slug": category_slug,
}
body = get_multipart_request_body(query, variables, image_file, image_name)
response = staff_api_client.post_multipart(
body, permissions=[permission_manage_products]
)
content = get_graphql_content(response)
data = content["data"]["categoryCreate"]
assert data["errors"] == []
assert data["category"]["name"] == category_name
assert data["category"]["description"] == category_description
assert data["category"]["descriptionJson"] == category_description_json
assert not data["category"]["parent"]
category = Category.objects.get(name=category_name)
assert category.background_image.file
mock_create_thumbnails.assert_called_once_with(category.pk)
assert data["category"]["backgroundImage"]["alt"] == image_alt
# test creating subcategory
parent_id = data["category"]["id"]
variables = {
"name": category_name,
"description": category_description,
"parentId": parent_id,
"slug": category_slug,
}
response = staff_api_client.post_graphql(query, variables)
content = get_graphql_content(response)
data = content["data"]["categoryCreate"]
assert data["errors"] == []
assert data["category"]["parent"]["id"] == parent_id
