def test_plugin_uses_configuration_from_db(
plugin_configuration,
monkeypatch,
address_usa,
site_settings,
address,
checkout_with_item,
shipping_zone,
discount_info,
settings,
):
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
configuration = plugin_configuration(username="******",
password="******",
sandbox=False)
manager = get_plugins_manager()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
site_settings.company_address = address_usa
site_settings.save()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info]
manager.preprocess_order_creation(checkout_with_item, discounts)
field_to_update = [
{
"name": "Username or account",
"value": "New value"
},
{
"name": "Password or license",
"value": "Wrong pass"
},
]
AvataxPlugin._update_config_items(field_to_update,
configuration.configuration)
configuration.save()
manager = get_plugins_manager()
with pytest.raises(TaxError):
manager.preprocess_order_creation(checkout_with_item, discounts)
def test_preprocess_order_creation(
checkout_with_item,
monkeypatch,
address,
address_usa,
site_settings,
shipping_zone,
discount_info,
plugin_configuration,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager(
plugins=["saleor.plugins.avatax.plugin.AvataxPlugin"])
site_settings.company_address = address_usa
site_settings.save()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
discounts = [discount_info]
manager.preprocess_order_creation(checkout_with_item, discounts)
def test_calculate_order_line_unit(
order_line,
shipping_zone,
site_settings,
address_usa,
plugin_configuration,
):
plugin_configuration()
manager = get_plugins_manager(
plugins=["saleor.plugins.avatax.plugin.AvataxPlugin"])
order_line.unit_price = TaxedMoney(net=Money("10.00", "USD"),
gross=Money("10.00", "USD"))
order_line.save()
order = order_line.order
method = shipping_zone.shipping_methods.get()
order.shipping_address = order.billing_address.get_copy()
order.shipping_method_name = method.name
order.shipping_method = method
order.save()
site_settings.company_address = address_usa
site_settings.save()
line_price = manager.calculate_order_line_unit(order_line)
line_price = quantize_price(line_price, line_price.currency)
assert line_price == TaxedMoney(net=Money("8.13", "USD"),
gross=Money("10.00", "USD"))
def test_calculate_checkout_shipping(
checkout_with_item,
shipping_zone,
discount_info,
address,
address_usa,
site_settings,
monkeypatch,
plugin_configuration,
):
plugin_configuration()
monkeypatch.setattr(
"saleor.plugins.avatax.plugin.get_cached_tax_codes_or_fetch",
lambda _: {"PC040156": "desc"},
)
manager = get_plugins_manager(
plugins=["saleor.plugins.avatax.plugin.AvataxPlugin"])
site_settings.company_address = address_usa
site_settings.save()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
shipping_price = manager.calculate_checkout_shipping(
checkout_with_item, list(checkout_with_item), [discount_info])
shipping_price = quantize_price(shipping_price, shipping_price.currency)
assert shipping_price == TaxedMoney(net=Money("8.13", "USD"),
gross=Money("10.00", "USD"))
def test_save_plugin_configuration_cannot_be_enabled_without_config(
settings, plugin_configuration):
plugin_configuration(None, None)
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
manager = get_plugins_manager()
with pytest.raises(ValidationError):
manager.save_plugin_configuration("Avalara", {"active": True})
def test_save_plugin_configuration(settings):
settings.PLUGINS = ["saleor.plugins.avatax.plugin.AvataxPlugin"]
manager = get_plugins_manager()
manager.save_plugin_configuration(
AvataxPlugin.PLUGIN_ID,
AvataxPlugin.PLUGIN_NAME,
{
"configuration": [
{
"name": "Username or account",
"value": "test"
},
{
"name": "Password or license",
"value": "test"
},
]
},
)
manager.save_plugin_configuration(AvataxPlugin.PLUGIN_ID,
AvataxPlugin.PLUGIN_NAME,
{"active": True})
plugin_configuration = PluginConfiguration.objects.get(
identifier=AvataxPlugin.PLUGIN_ID)
assert plugin_configuration.active
def test_save_plugin_configuration_cannot_be_enabled_without_config(settings):
settings.PLUGINS = ["saleor.plugins.vatlayer.plugin.VatlayerPlugin"]
manager = get_plugins_manager()
with pytest.raises(ValidationError):
manager.save_plugin_configuration(VatlayerPlugin.PLUGIN_ID,
VatlayerPlugin.PLUGIN_NAME,
{"active": True})
def save_token_in_plugin_configuration(access_token, refresh_token,
expires_in):
cleaned_data = {
"configuration": [{
"name": "token_value",
"value": access_token
}, {
"name":
"token_access",
"value":
(datetime.now() +
timedelta(seconds=expires_in)).strftime("%d/%m/%Y %H:%M:%S")
}, {
"name": "refresh_token",
"value": refresh_token
}]
}
manager = get_plugins_manager()
plugin = manager.get_plugin('allegro')
plugin.save_plugin_configuration(
plugin_configuration=PluginConfiguration.objects.get(
identifier=plugin.PLUGIN_ID),
cleaned_data=cleaned_data)
def test_save_plugin_configuration(api_get_request_mock, settings,
channel_USD):
settings.PLUGINS = [
"saleor.plugins.avatax.excise.plugin.AvataxExcisePlugin"
]
api_get_request_mock.return_value = {"authenticated": True}
manager = get_plugins_manager()
manager.save_plugin_configuration(
AvataxExcisePlugin.PLUGIN_ID,
channel_USD.slug,
{
"active":
True,
"configuration": [
{
"name": "Username or account",
"value": "test"
},
{
"name": "Password or license",
"value": "test"
},
],
},
)
manager.save_plugin_configuration(AvataxExcisePlugin.PLUGIN_ID,
channel_USD, {"active": True})
plugin_configuration = PluginConfiguration.objects.get(
identifier=AvataxExcisePlugin.PLUGIN_ID)
assert plugin_configuration.active
def test_base_plugin__append_config_structure_to_config(settings):
settings.PLUGINS = ["tests.plugins.sample_plugins.PluginSample"]
manager = get_plugins_manager()
plugin = manager.get_plugin(PluginSample.PLUGIN_ID)
config = [
{
"name": "Username",
"value": "my_test_user"
},
{
"name": "Password",
"value": "my_password"
},
]
config_with_structure = [
{
"name": "Username",
"value": "my_test_user",
"type": "String",
"help_text": "Username input field",
"label": "Username",
},
{
"name": "Password",
"value": "my_password",
"type": "Password",
"help_text": "Password input field",
"label": "Password",
},
]
plugin._append_config_structure(config)
assert config == config_with_structure
def test_plugin_configuration_update(staff_api_client_can_manage_plugins,
settings, active,
updated_configuration_item):
settings.PLUGINS = ["saleor.plugins.tests.sample_plugins.PluginSample"]
manager = get_plugins_manager()
plugin = manager.get_plugin(PluginSample.PLUGIN_ID)
old_configuration = copy.deepcopy(plugin.configuration)
variables = {
"id": plugin.PLUGIN_ID,
"active": active,
"configuration": [updated_configuration_item],
}
response = staff_api_client_can_manage_plugins.post_graphql(
PLUGIN_UPDATE_MUTATION, variables)
get_graphql_content(response)
plugin = PluginConfiguration.objects.get(identifier=PluginSample.PLUGIN_ID)
assert plugin.active == active
first_configuration_item = plugin.configuration[0]
assert first_configuration_item["name"] == updated_configuration_item[
"name"]
assert first_configuration_item["value"] == updated_configuration_item[
"value"]
second_configuration_item = plugin.configuration[1]
assert second_configuration_item["name"] == old_configuration[1]["name"]
assert second_configuration_item["value"] == old_configuration[1]["value"]
def test_get_plugins_manager():
manager_path = "saleor.plugins.manager.PluginsManager"
plugin_path = "tests.plugins.sample_plugins.PluginSample"
manager = get_plugins_manager(manager_path=manager_path,
plugins=[plugin_path])
assert isinstance(manager, PluginsManager)
assert len(manager.plugins) == 1
def test_query_plugin_hides_secret_fields(
password,
expected_password,
api_key,
expected_api_key,
staff_api_client,
permission_manage_plugins,
settings,
):
settings.PLUGINS = ["tests.api.test_plugins.PluginSample"]
manager = get_plugins_manager()
plugin = manager.get_plugin(PluginSample.PLUGIN_NAME)
configuration = copy.deepcopy(plugin.configuration)
for conf_field in configuration:
if conf_field["name"] == "Password":
conf_field["value"] = password
if conf_field["name"] == "API private key":
conf_field["value"] = api_key
manager.save_plugin_configuration(
PluginSample.PLUGIN_NAME, {"active": True, "configuration": configuration}
)
variables = {"id": plugin.PLUGIN_NAME}
staff_api_client.user.user_permissions.add(permission_manage_plugins)
response = staff_api_client.post_graphql(PLUGIN_QUERY, variables)
content = get_graphql_content(response)
plugin = content["data"]["plugin"]
for conf_field in plugin["configuration"]:
if conf_field["name"] == "Password":
assert conf_field["value"] == expected_password
if conf_field["name"] == "API private key":
assert conf_field["value"] == expected_api_key
def test_query_plugin_configurations(staff_api_client_can_manage_plugins,
settings):
# Enable test plugin
settings.PLUGINS = ["saleor.plugins.tests.sample_plugins.PluginSample"]
response = staff_api_client_can_manage_plugins.post_graphql(PLUGINS_QUERY)
content = get_graphql_content(response)
plugins = content["data"]["plugins"]["edges"]
assert len(plugins) == 1
plugin = plugins[0]["node"]
manager = get_plugins_manager()
sample_plugin = manager.get_plugin(PluginSample.PLUGIN_ID)
confiugration_structure = PluginSample.CONFIG_STRUCTURE
assert plugin["id"] == sample_plugin.PLUGIN_ID
assert plugin["name"] == sample_plugin.PLUGIN_NAME
assert plugin["active"] == sample_plugin.DEFAULT_ACTIVE
assert plugin["description"] == sample_plugin.PLUGIN_DESCRIPTION
for index, configuration_item in enumerate(plugin["configuration"]):
assert configuration_item["name"] == sample_plugin.configuration[
index]["name"]
if (confiugration_structure[configuration_item["name"]]["type"] ==
ConfigurationTypeField.STRING):
assert (configuration_item["value"] ==
sample_plugin.configuration[index]["value"])
elif configuration_item["value"] is None:
assert not sample_plugin.configuration[index]["value"]
else:
assert (configuration_item["value"] == str(
sample_plugin.configuration[index]["value"]).lower())
def test_calculate_checkout_shipping(
reset_sequences, # pylint: disable=unused-argument
checkout_with_item,
shipping_zone,
discount_info,
address_usa_tx,
address,
site_settings,
plugin_configuration,
):
plugin_configuration()
manager = get_plugins_manager()
site_settings.company_address = address
site_settings.save()
checkout_with_item.shipping_address = address_usa_tx
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
lines = fetch_checkout_lines(checkout_with_item)
checkout_info = fetch_checkout_info(checkout_with_item, lines,
[discount_info], manager)
shipping_price = manager.calculate_checkout_shipping(
checkout_info, lines, address, [discount_info])
shipping_price = quantize_price(shipping_price, shipping_price.currency)
assert shipping_price == TaxedMoney(net=Money("10.00", "USD"),
gross=Money("10.00", "USD"))
def test_save_plugin_configuration_authentication_failed(
api_get_request_mock, settings, channel_USD):
settings.PLUGINS = [
"saleor.plugins.avatax.excise.plugin.AvataxExcisePlugin"
]
api_get_request_mock.return_value = {"authenticated": False}
manager = get_plugins_manager()
with pytest.raises(ValidationError) as e:
manager.save_plugin_configuration(
AvataxExcisePlugin.PLUGIN_ID,
channel_USD.slug,
{
"active":
True,
"configuration": [
{
"name": "Username or account",
"value": "test"
},
{
"name": "Password or license",
"value": "test"
},
],
},
)
assert e._excinfo[1].args[
0] == "Authentication failed. Please check provided data."
plugin_configuration = PluginConfiguration.objects.get(
identifier=AvataxExcisePlugin.PLUGIN_ID)
assert not plugin_configuration.active
def test_save_plugin_configuration_invalid(settings, channel_USD):
settings.PLUGINS = [
"saleor.plugins.avatax.excise.plugin.AvataxExcisePlugin"
]
manager = get_plugins_manager()
with pytest.raises(ValidationError):
manager.save_plugin_configuration(
AvataxExcisePlugin.PLUGIN_ID,
channel_USD.slug,
{
"active":
True,
"configuration": [
{
"name": "Username or account",
"value": ""
},
{
"name": "Password or license",
"value": ""
},
],
},
)
plugin_configuration = PluginConfiguration.objects.get(
identifier=AvataxExcisePlugin.PLUGIN_ID)
assert not plugin_configuration.active
def test_get_tax_rate_percentage_value(vatlayer, order_line, shipping_zone,
site_settings, product):
manager = get_plugins_manager(
plugins=["saleor.plugins.vatlayer.plugin.VatlayerPlugin"])
country = Country("PL")
tax_rate = manager.get_tax_rate_percentage_value(product, country)
assert tax_rate == Decimal("23")
def test_calculate_checkout_subtotal(
site_settings,
vatlayer,
checkout_with_item,
address,
shipping_zone,
discount_info,
with_discount,
expected_net,
expected_gross,
taxes_in_prices,
stock,
):
variant = stock.product_variant
site_settings.include_taxes_in_prices = taxes_in_prices
site_settings.save()
checkout_with_item.shipping_address = address
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.save()
manager = get_plugins_manager(
plugins=["saleor.plugins.vatlayer.plugin.VatlayerPlugin"])
product = variant.product
manager.assign_tax_code_to_object_meta(product, "standard")
product.save()
discounts = [discount_info] if with_discount else None
add_variant_to_checkout(checkout_with_item, variant, 2)
total = manager.calculate_checkout_subtotal(checkout_with_item, discounts)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(net=Money(expected_net, "USD"),
gross=Money(expected_gross, "USD"))
def test_calculate_checkout_total(
reset_sequences, # pylint: disable=unused-argument
with_discount,
expected_net,
expected_gross,
voucher_amount,
taxes_in_prices,
checkout_with_item,
product_with_single_variant,
discount_info,
shipping_zone,
address_usa_tx,
address_usa,
site_settings,
monkeypatch,
plugin_configuration,
non_default_category,
):
plugin_configuration()
# Required ATE variant data
metadata = {
get_metadata_key("UnitQuantity"): 1,
}
ProductVariant.objects.filter(sku="SKU_SINGLE_VARIANT").update(
sku="202127000", private_metadata=metadata)
monkeypatch.setattr(
"saleor.plugins.avatax.excise.plugin.AvataxExcisePlugin._skip_plugin",
lambda *_: False,
)
manager = get_plugins_manager()
checkout_with_item.shipping_address = address_usa_tx
checkout_with_item.save()
site_settings.company_address = address_usa
site_settings.include_taxes_in_prices = taxes_in_prices
site_settings.save()
voucher_amount = Money(voucher_amount, "USD")
checkout_with_item.shipping_method = shipping_zone.shipping_methods.get()
checkout_with_item.discount = voucher_amount
checkout_with_item.save()
product_with_single_variant.charge_taxes = False
product_with_single_variant.category = non_default_category
product_with_single_variant.save()
discounts = [discount_info] if with_discount else None
discount_amount = Decimal("1.00") if with_discount else Decimal("0.00")
checkout_with_item.discount_amount = discount_amount
checkout_info = fetch_checkout_info(checkout_with_item, [], discounts,
manager)
add_variant_to_checkout(checkout_info,
product_with_single_variant.variants.get())
lines = fetch_checkout_lines(checkout_with_item)
total = manager.calculate_checkout_total(checkout_info, lines,
address_usa_tx, discounts)
total = quantize_price(total, total.currency)
assert total == TaxedMoney(net=Money(expected_net, "USD"),
gross=Money(expected_gross, "USD"))
def get_plugin_configuration():
manager = get_plugins_manager()
plugin = manager.get_plugin('allegro')
configuration = {
item["name"]: item["value"]
for item in plugin.configuration
}
return configuration
def test_calculate_checkout_total_skip(skip_mock, checkout_with_item,
address_usa, plugin_configuration):
skip_mock.return_value = True
plugin_configuration()
manager = get_plugins_manager()
checkout_info = fetch_checkout_info(checkout_with_item, [], [], manager)
manager.calculate_checkout_total(checkout_info, [], [], [])
skip_mock.assert_called_once
def test_skip_diabled_plugin(settings):
settings.PLUGINS = ["saleor.plugins.vatlayer.plugin.VatlayerPlugin"]
manager = get_plugins_manager()
plugin: VatlayerPlugin = manager.get_plugin(VatlayerPlugin.PLUGIN_ID)
assert (plugin._skip_plugin(
previous_value=TaxedMoney(net=Money(0, "USD"), gross=Money(0, "USD")))
is True)
def get_configuration():
manager = get_plugins_manager()
plugin = manager.get_plugin(SumiPlugin.PLUGIN_ID)
configuration = {
item["name"]: item["value"]
for item in plugin.configuration
}
return configuration
def create_payments_customer_ids():
plugins = get_plugins_manager().plugins
return {
f"{plugin.PLUGIN_NAME.strip().upper()}.customer_id":
f"{plugin.PLUGIN_ID.strip().upper()}.customer_id" # noqa E501
for plugin in plugins
}
def test_save_plugin_configuration(vatlayer, settings):
settings.PLUGINS = ["saleor.plugins.vatlayer.plugin.VatlayerPlugin"]
manager = get_plugins_manager()
manager.save_plugin_configuration("Vatlayer", {"active": False})
configuration = PluginConfiguration.objects.get(
name=VatlayerPlugin.PLUGIN_NAME)
assert not configuration.active
def test_customer_created(mocked_webhook_trigger, settings, customer_user):
settings.PLUGINS = ["saleor.plugins.webhook.plugin.WebhookPlugin"]
manager = get_plugins_manager()
manager.customer_created(customer_user)
expected_data = generate_customer_payload(customer_user)
mocked_webhook_trigger.assert_called_once_with(
WebhookEventType.CUSTOMER_CREATED, expected_data
)
def test_product_created(mocked_webhook_trigger, settings, product):
settings.PLUGINS = ["saleor.plugins.webhook.plugin.WebhookPlugin"]
manager = get_plugins_manager()
manager.product_created(product)
expected_data = generate_product_payload(product)
mocked_webhook_trigger.assert_called_once_with(
WebhookEventType.PRODUCT_CREATED, expected_data
)
def test_order_cancelled(mocked_webhook_trigger, settings, order_with_lines):
settings.PLUGINS = ["saleor.plugins.webhook.plugin.WebhookPlugin"]
manager = get_plugins_manager()
manager.order_cancelled(order_with_lines)
expected_data = generate_order_payload(order_with_lines)
mocked_webhook_trigger.assert_called_once_with(
WebhookEventType.ORDER_CANCELLED, expected_data
)
def test_calculate_order_shipping_for_order_without_shipping(
vatlayer, order_line, shipping_zone, site_settings):
manager = get_plugins_manager(
plugins=["saleor.plugins.vatlayer.plugin.VatlayerPlugin"])
order = order_line.order
order.shipping_method = None
order.save()
price = manager.calculate_order_shipping(order)
assert price == zero_taxed_money(order.currency)
