def test_utils_delete_entities_all(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
utils.store(self.testdata["items"], models.Item, "items", self.request)
utils.delete_all("items", self.request)
items = [x for x in self.app_root["items"].items()]
assert (items == [])
def test_utils_store_entities_with_unit_of_measure(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
self.testdata["items"][0]["unit_of_measure_id"] = "unit"
unit = models.EntityData()
self.app_root["unit_of_measures"]["unit"] = unit
utils.store(self.testdata["items"], models.Item, "items", self.request)
item = self.app_root["items"]["itemka32"]
assert item.unit_of_measure == unit
def test_utils_store_entities_with_vpe_type(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
self.testdata["items"][0]["vpe_type_id"] = "portion"
vpe_type = models.EntityData()
self.app_root["vpe_types"]["portion"] = vpe_type
utils.store(self.testdata["items"], models.Item, "items", self.request)
item = self.app_root["items"]["itemka32"]
assert item.vpe_type == vpe_type
def vpe_types_put(request):
"""Update vpe type data (for items).
request body :
* vpe_types: Sequence of VPEType
"""
utils.store(request.validated["vpe_types"], models.EntityData, "vpe_types",
request)
return {"status": "succeeded"}
def unit_of_measures_put(request):
"""Update unit of measure data (for items)
reqeust body :
* Sequence of UnitOfMeasure
"""
utils.store(request.validated["unit_of_measures"], models.EntityData,
"unit_of_measures", request)
return {"status": "succeeded"}
def test_utils_delete_entities(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
from repoze.catalog.query import Eq
utils.store(self.testdata["items"], models.Item, "items", self.request)
utils.delete(self.testdata["items"], "items", self.request)
items = [x for x in self.app_root["items"].items()]
assert (items == [])
catalog = self.app_root["catalog"]
search_results = catalog.query(Eq('id', 'itemka32'))[0]
assert (search_results == 0)
def vpe_types_post(request):
"""Create new vpe type data (for items).
You should delete referencing items first.
request body :
* vpe_types: Sequence of VPEType
"""
utils.store(request.validated["vpe_types"], models.EntityData, "vpe_types",
request)
return {"status": "succeeded"}
def test_utils_store_entities_with_parent_missing(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
self.testdata["items"][0]["parent_id"] = "wrong_id"
self.testdata["items"][0]["id"] = "itemka32"
parent = models.ItemGroup()
self.app_root["item_groups"]["karotten"] = parent
models.ItemGroup().__children__
utils.store(self.testdata["items"], models.Item, "items", self.request)
item = self.app_root["items"]["itemka32"]
assert item.__parent__ is None
assert parent.__children__ == []
def test_utils_store_entities_with_quality(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
quality = {"id": "quality"}
parent = models.ItemGroup()
parent.from_appstruct({"qualities": [quality]})
self.app_root["item_groups"]["parent"] = parent
self.testdata["items"][0]["parent_id"] = "parent"
self.testdata["items"][0]["quality_id"] = "quality"
utils.store(self.testdata["items"], models.Item, "items", self.request)
item = self.app_root["items"]["itemka32"]
assert item.quality is quality
def test_utils_store_entities_update_parent(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
self.testdata["items"][0]["parent_id"] = "karotten"
self.testdata["items"][0]["id"] = "itemka32"
item = utils.store(self.testdata["items"], models.Item, "items",
self.request)[0]
parent = utils.store([{
"id": "karotten"
}], models.ItemGroup, "item_groups", self.request)[0]
assert item.__parent__ is parent
assert parent.__children__ == [item]
def test_utils_store_entities_with_quality_wrong_id(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
from organicseeds_webshop_api.exceptions import _400
quality = {"id": "quality"}
parent = models.ItemGroup()
parent.from_appstruct({"qualities": [quality]})
self.app_root["item_groups"]["parent"] = parent
self.testdata["items"][0]["parent_id"] = "parent"
self.testdata["items"][0]["wrong_quality_id"] = "quality"
with pytest.raises(_400):
utils.store(self.testdata["items"], models.Item, "items",
self.request)
def item_groups_post(request):
"""Create new item group entities
request body :
* item_groups : Sequence of ItemGroup
"""
save_in_webshop = request.validated.get("save_in_webshop", True)
appstructs = request.validated["item_groups"]
item_groups = utils.store(appstructs, models.ItemGroup, "item_groups",
request)
if save_in_webshop:
with magentoapi.ItemGroups(request) as proxy:
try:
# create item_groups in webshop
webshop_ids = proxy.create(appstructs)
utils.set_webshop_ids(item_groups, webshop_ids)
# activate categories in webshop shops
proxy.update_shops(webshop_ids, appstructs)
# link item_group parents in webshop
proxy.link_item_parents(webshop_ids, appstructs)
# link item_group children in webshop
item_webshop_ids, items = utils.get_entities_item_children(
item_groups, request)
proxy.link_item_parents(item_webshop_ids, items)
except exceptions._502 as e:
proxy.delete([x for x in e.success if isinstance(x, int)])
raise
magentoapi.indexing_reindex(request)
return {"status": "succeeded"}
def test_utils_store_entities_update_item_quality_missing(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
child = models.Item()
child.from_appstruct({
"id": "child",
"parent_id": "parent",
"quality_id": "quality"
})
self.app_root["items"]["child"] = child
utils.store([{
"id": "parent",
"qualities": []
}], models.ItemGroup, "item_groups", self.request)
assert child.quality is None
def test_utils_store_entities_update_item_quality(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
quality = {"id": "quality"}
child_appstruct = {
"id": "child",
"parent_id": "parent",
"quality_id": "quality"
}
childs = utils.store([child_appstruct], models.Item, "items",
self.request)
child = childs[0]
utils.store([{
"id": "parent",
"qualities": [quality]
}], models.ItemGroup, "item_groups", self.request)
assert child.quality is quality
def test_utils_store_entities_update_item_quality_wrong_id(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
from organicseeds_webshop_api.exceptions import _400
quality = {"id": "quality"}
child_appstruct = {
"id": "child",
"parent_id": "parent",
"quality_id": "wrong_id"
}
utils.store([child_appstruct], models.Item, "items", self.request)
with pytest.raises(_400):
quality = {"id": "quality"}
utils.store([{
"id": "parent",
"qualities": [quality]
}], models.ItemGroup, "item_groups", self.request)
def test_utils_search_OR(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
appstructs = [{
"id": "item1",
"__type__": "vpe1",
"title": {
"default": "title"
}
}, {
"id": "item2",
"__type__": "vpe2",
"title": {
"default": "title"
}
}]
utils.store(appstructs, models.Item, "items", self.request)
kwargs = {"id": "item1", "__type__": "vpe2"}
results = utils.search(self.request, operator="OR", **kwargs)
assert len(results) == 2
def test_utils_delete_entities_with_parents(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
item = utils.store(self.testdata["items"], models.Item, "items",
self.request)[0]
parent = models.ItemGroup()
item.__parent__ = parent
parent.__children__.append(item)
utils.delete(self.testdata["items"], "items", self.request)
assert item.__parent__ is None
assert item not in parent.__children__
def test_item_group_get(self):
from organicseeds_webshop_api.testing import set_testfile
from organicseeds_webshop_api.services import item_group_get
from organicseeds_webshop_api import models
from organicseeds_webshop_api import utils
cattests = set_testfile("/testdata/categories_post.yaml")["testdata"]
utils.store(cattests["categories"], models.Category, "categories",
self.request)
item_groups = utils.store(self.testdata["item_groups"],
models.ItemGroup, "item_groups",
self.request)
item_group = item_groups[0]
self.request.validated = {
"id": item_group["id"],
"lang": "default",
"with_children": False,
"children_shop_id": ""
}
response = item_group_get(self.request)
assert response["title"] == item_group["title"]["default"]
def test_utils_store_entities(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
from repoze.catalog.query import Eq
catalog = self.app_root["catalog"]
self.testdata["items"][0]["title"] = {"default": "Aktuelle Aussaten"}
items = utils.store(self.testdata["items"], models.Item, "items",
self.request)
assert len(items) == len(self.testdata["items"])
results = catalog.query(Eq('id', 'itemka32'))[0]
assert (results == 1)
def items_put(request):
"""Update existing item entities
request body :
* items: Sequence of ItemUpdate
"""
save_in_webshop = request.validated.get("save_in_webshop", True)
appstructs = utils.remove_none_values(request.validated["items"])
utils.store(appstructs, models.Item, "items", request)
items = request.root.app_root["items"]
if save_in_webshop:
magentoapi.indexing_enable_manual(request)
with magentoapi.Items(request) as proxy:
webshop_ids = []
for a in appstructs:
webshop_id = items[a["id"]].webshop_id
webshop_ids.append(webshop_id)
proxy.update(appstructs)
proxy.update_shops(webshop_ids, appstructs)
magentoapi.indexing_reindex(request)
return {"status": "succeeded"}
def test_utils_store_entities_with_url_slug(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
from organicseeds_webshop_api.url_normalizer import url_normalizer
from repoze.catalog.query import Eq
catalog = self.app_root["catalog"]
appstructs = [{
"id": "1",
"sku": "sku1",
"title": {
"default": "title",
"fr": u"titlé fr"
}
}]
item = utils.store(appstructs, models.Item, "items", self.request)[0]
assert item["url_slug"]["default"] == url_normalizer('title' + "-1")
assert item["url_slug"]["fr"] == url_normalizer(u'titlé fr') + "-1-fr"
results = catalog.query(
Eq('title_url_slugs',
url_normalizer(u'titlé fr') + "-1-fr"))[0]
assert (results == 1)
def items_post(request):
"""Create new item entities
body :
* Sequence of Item
"""
save_in_webshop = request.validated.get("save_in_webshop", True)
appstructs = request.validated["items"]
items = utils.store(appstructs, models.Item, "items", request)
if save_in_webshop:
magentoapi.indexing_enable_manual(request)
with magentoapi.Items(request) as proxy:
try:
webshop_ids = proxy.create(appstructs)
utils.set_webshop_ids(items, webshop_ids)
proxy.update_shops(webshop_ids, appstructs)
proxy.link_item_parents(webshop_ids, appstructs)
except exceptions._502 as e:
proxy.delete([x for x in e.success if isinstance(x, int)])
raise
magentoapi.indexing_reindex(request)
return {"status": "succeeded"}
def test_utils_store_entities_with_vpe_type_missing(self):
from organicseeds_webshop_api import utils
from organicseeds_webshop_api import models
utils.store(self.testdata["items"], models.Item, "items", self.request)
item = self.app_root["items"]["itemka32"]
assert item.vpe_type is None
