def clear_tables(self):
from invenio.modules.workflows.models import Workflow, BibWorkflowObject
from invenio.ext.sqlalchemy import db
dep_workflows = Workflow.get(
Workflow.module_name == "webdeposit").all()
for workflow in dep_workflows:
BibWorkflowObject.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid).delete()
Workflow.get(Workflow.module_name == "webdeposit").delete()
db.session.commit()
def clear_tables(self):
from invenio.modules.workflows.models import Workflow, BibWorkflowObject
from invenio.ext.sqlalchemy import db
dep_workflows = Workflow.get(
Workflow.module_name == "webdeposit"
).all()
for workflow in dep_workflows:
BibWorkflowObject.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid
).delete()
Workflow.get(Workflow.module_name == "webdeposit").delete()
db.session.commit()
def test_deleting_workflow(self):
"""Test deleting workflow."""
from invenio.modules.workflows.models import BibWorkflowObject, \
Workflow
bwo_id = self.bibworkflowobject.id
# delete workflow
Workflow.delete(self.workflow.uuid)
# assert bibworkflowobject is deleted
self.assertFalse(
db.session.query(
BibWorkflowObject.query.filter(
BibWorkflowObject.id == bwo_id).exists()).scalar())
def test_deleting_workflow(self):
"""Test deleting workflow."""
from invenio.modules.workflows.models import BibWorkflowObject, \
Workflow
bwo_id = self.bibworkflowobject.id
# delete workflow
Workflow.delete(self.workflow.uuid)
# assert bibworkflowobject is deleted
self.assertFalse(
db.session.query(
BibWorkflowObject.query.filter(
BibWorkflowObject.id == bwo_id).exists()).scalar())
def test_form_functions(self):
from invenio_deposit.loader import \
deposition_metadata
from invenio_deposit import forms
from invenio.webdeposit_workflow import DepositionWorkflow
from invenio.webdeposit_utils import get_form, \
get_form_status, set_form_status, CFG_DRAFT_STATUS
from invenio.modules.workflows.models import Workflow
for metadata in deposition_metadata.values():
for wf_function in metadata['workflow']:
if 'render_form' == wf_function.func_name:
break
user_id = self.login_user()
deposition_workflow = DepositionWorkflow(deposition_type='Article',
user_id=user_id)
uuid = deposition_workflow.get_uuid()
# Run the workflow to insert a form in the db
deposition_workflow.run()
# There is only one form in the db
workflows = Workflow.get(module_name='webdeposit')
assert len(workflows.all()) == 1
assert len(workflows[0].extra_data['drafts']) == 1
# Test that guest user doesn't have access to the form
form = get_form(0, uuid=uuid)
assert form is None
# Test that the current form has the right type
form = get_form(user_id, uuid=deposition_workflow.get_uuid())
assert isinstance(form, forms['ArticleForm'])
assert str(uuid) == str(deposition_workflow.get_uuid())
# Test that form is returned with get_form function
form = get_form(user_id, deposition_workflow.get_uuid())
assert form is not None
form = get_form(user_id, deposition_workflow.get_uuid(), step=0)
assert form is not None
# Second step doesn't have a form
form = get_form(user_id, deposition_workflow.get_uuid(), step=1)
assert form is None
form_status = get_form_status(user_id, deposition_workflow.get_uuid())
assert form_status == CFG_DRAFT_STATUS['unfinished']
form_status = get_form_status(user_id,
deposition_workflow.get_uuid(),
step=2)
assert form_status is None
set_form_status(user_id, uuid, CFG_DRAFT_STATUS['finished'])
form_status = get_form_status(user_id, deposition_workflow.get_uuid())
assert form_status == CFG_DRAFT_STATUS['finished']
def test_form_functions(self):
from invenio_deposit.loader import \
deposition_metadata
from invenio_deposit import forms
from invenio.webdeposit_workflow import DepositionWorkflow
from invenio.webdeposit_utils import get_form, \
get_form_status, set_form_status, CFG_DRAFT_STATUS
from invenio.modules.workflows.models import Workflow
for metadata in deposition_metadata.values():
for wf_function in metadata['workflow']:
if 'render_form' == wf_function.func_name:
break
user_id = self.login_user()
deposition_workflow = DepositionWorkflow(deposition_type='Article',
user_id=user_id)
uuid = deposition_workflow.get_uuid()
# Run the workflow to insert a form in the db
deposition_workflow.run()
# There is only one form in the db
workflows = Workflow.get(module_name='webdeposit')
assert len(workflows.all()) == 1
assert len(workflows[0].extra_data['drafts']) == 1
# Test that guest user doesn't have access to the form
form = get_form(0, uuid=uuid)
assert form is None
# Test that the current form has the right type
form = get_form(user_id, uuid=deposition_workflow.get_uuid())
assert isinstance(form, forms['ArticleForm'])
assert str(uuid) == str(deposition_workflow.get_uuid())
# Test that form is returned with get_form function
form = get_form(user_id, deposition_workflow.get_uuid())
assert form is not None
form = get_form(user_id, deposition_workflow.get_uuid(), step=0)
assert form is not None
# Second step doesn't have a form
form = get_form(user_id, deposition_workflow.get_uuid(), step=1)
assert form is None
form_status = get_form_status(user_id, deposition_workflow.get_uuid())
assert form_status == CFG_DRAFT_STATUS['unfinished']
form_status = get_form_status(user_id, deposition_workflow.get_uuid(),
step=2)
assert form_status is None
set_form_status(user_id, uuid, CFG_DRAFT_STATUS['finished'])
form_status = get_form_status(user_id, deposition_workflow.get_uuid())
assert form_status == CFG_DRAFT_STATUS['finished']
def delete(self):
"""
Delete the current deposition
"""
if not self.authorize('delete'):
raise DepositionNotDeletable(self)
for f in self.files:
f.delete()
if self.workflow_object.id_workflow:
Workflow.delete(uuid=self.workflow_object.id_workflow)
BibWorkflowObject.query.filter_by(
id_workflow=self.workflow_object.id_workflow).delete()
else:
db.session.delete(self.workflow_object)
db.session.commit()
def test_workflow_creation(self):
from invenio_deposit.loader import \
deposition_metadata
from invenio.modules.workflows.models import Workflow
from invenio.webdeposit_workflow import DepositionWorkflow
from invenio.webdeposit_utils import get_latest_or_new_workflow, \
get_workflow, delete_workflow, InvenioWebDepositNoDepositionType
user_id = self.login_user()
number_of_dep_types = len(deposition_metadata)
# Test for every deposition type
for deposition_type in deposition_metadata.keys():
# New workflow is created
workflow = get_latest_or_new_workflow(deposition_type,
user_id=user_id)
self.assertTrue(workflow is not None)
# The just created workflow is retrieved as latest
workflow2 = get_latest_or_new_workflow(deposition_type,
user_id=user_id)
self.assertTrue(workflow2 is not None)
self.assertEqual(str(workflow2.uuid), str(workflow.uuid))
# and also retrieved with its uuid
workflow = get_workflow(workflow.uuid, deposition_type)
self.assertTrue(workflow is not None)
# Test get_workflow function with random arguments
deposition_type = deposition_metadata.keys()[-1]
workflow = get_workflow('some_uuid_that_doesnt_exist', deposition_type)
self.assertTrue(workflow is None)
# Create workflow without using webdeposit_utils
workflow = DepositionWorkflow(deposition_type=deposition_type,
user_id=1)
self.assertRaises(InvenioWebDepositNoDepositionType,
get_workflow, workflow.get_uuid(),
'deposition_type_that_doesnt_exist')
# Test that the retrieved workflow is the same and not None
workflow2 = get_workflow(workflow.get_uuid(), deposition_type)
self.assertTrue(workflow2 is not None)
self.assertEqual(workflow2.get_uuid(), workflow.get_uuid())
# Check the number of created workflows
count_workflows = Workflow.get(
Workflow.module_name == "webdeposit"
).count()
self.assertEqual(count_workflows, number_of_dep_types + 1)
uuid = workflow.get_uuid()
delete_workflow(1, uuid)
workflow = get_workflow(uuid, deposition_type)
self.assertTrue(workflow is None)
def test_workflow_creation(self):
from invenio_deposit.loader import \
deposition_metadata
from invenio.modules.workflows.models import Workflow
from invenio.webdeposit_workflow import DepositionWorkflow
from invenio.webdeposit_utils import get_latest_or_new_workflow, \
get_workflow, delete_workflow, InvenioWebDepositNoDepositionType
user_id = self.login_user()
number_of_dep_types = len(deposition_metadata)
# Test for every deposition type
for deposition_type in deposition_metadata.keys():
# New workflow is created
workflow = get_latest_or_new_workflow(deposition_type,
user_id=user_id)
self.assertTrue(workflow is not None)
# The just created workflow is retrieved as latest
workflow2 = get_latest_or_new_workflow(deposition_type,
user_id=user_id)
self.assertTrue(workflow2 is not None)
self.assertEqual(str(workflow2.uuid), str(workflow.uuid))
# and also retrieved with its uuid
workflow = get_workflow(workflow.uuid, deposition_type)
self.assertTrue(workflow is not None)
# Test get_workflow function with random arguments
deposition_type = deposition_metadata.keys()[-1]
workflow = get_workflow('some_uuid_that_doesnt_exist', deposition_type)
self.assertTrue(workflow is None)
# Create workflow without using webdeposit_utils
workflow = DepositionWorkflow(deposition_type=deposition_type,
user_id=1)
self.assertRaises(InvenioWebDepositNoDepositionType, get_workflow,
workflow.get_uuid(),
'deposition_type_that_doesnt_exist')
# Test that the retrieved workflow is the same and not None
workflow2 = get_workflow(workflow.get_uuid(), deposition_type)
self.assertTrue(workflow2 is not None)
self.assertEqual(workflow2.get_uuid(), workflow.get_uuid())
# Check the number of created workflows
count_workflows = Workflow.get(
Workflow.module_name == "webdeposit").count()
self.assertEqual(count_workflows, number_of_dep_types + 1)
uuid = workflow.get_uuid()
delete_workflow(1, uuid)
workflow = get_workflow(uuid, deposition_type)
self.assertTrue(workflow is None)
def delete(self):
"""
Delete the current deposition
"""
if not self.authorize('delete'):
raise DepositionNotDeletable(self)
for f in self.files:
f.delete()
if self.workflow_object.id_workflow:
Workflow.delete(uuid=self.workflow_object.id_workflow)
BibWorkflowObject.query.filter_by(
id_workflow=self.workflow_object.id_workflow
).delete()
else:
db.session.delete(self.workflow_object)
db.session.commit()
def test_workflow_engine_instantiation(self):
"""Check the proper init of the Workflow and BibWorkflowEngine."""
from invenio.modules.workflows.models import Workflow
from invenio.modules.workflows.engine import BibWorkflowEngine
from uuid import uuid1 as new_uuid
test_workflow = Workflow(name='test_workflow', uuid=new_uuid(),
id_user=0, module_name="Unknown", )
test_workflow_engine = BibWorkflowEngine(name=test_workflow.name,
uuid=test_workflow.uuid)
self.assertEqual(test_workflow.name, test_workflow_engine.name)
def setUp(self):
"""Setup tests."""
from invenio.modules.workflows.models import BibWorkflowObject, \
Workflow
from uuid import uuid1 as new_uuid
self.workflow = Workflow(name='test_workflow',
uuid=new_uuid(),
id_user=0,
module_name="Unknown")
self.bibworkflowobject = BibWorkflowObject(workflow=self.workflow)
self.create_objects([self.workflow, self.bibworkflowobject])
def tearDown(self):
""" Clean up created objects """
from invenio.modules.workflows.models import (BibWorkflowObject,
Workflow,
BibWorkflowEngineLog,
BibWorkflowObjectLog)
from invenio.modules.workflows.utils import get_redis_keys, set_up_redis
workflows = Workflow.get(Workflow.module_name == "unit_tests").all()
for workflow in workflows:
BibWorkflowObject.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid).delete()
objects = BibWorkflowObjectLog.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid).all()
for obj in objects:
db.session.delete(obj)
db.session.delete(workflow)
objects = BibWorkflowObjectLog.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid).all()
for obj in objects:
BibWorkflowObjectLog.delete(id=obj.id)
BibWorkflowEngineLog.delete(uuid=workflow.uuid)
# Deleting dumy object created in tests
db.session.query(BibWorkflowObject).filter(
BibWorkflowObject.id_workflow.in_(
[11, 123, 253])).delete(synchronize_session='fetch')
Workflow.query.filter(Workflow.module_name == "unit_tests").delete()
db.session.commit()
rs = set_up_redis()
keys = get_redis_keys()
for key in keys:
keys2 = get_redis_keys(key)
for key2 in keys2:
rs.delete("holdingpen_sort:%s:%s" % (
key,
key2,
))
rs.delete("holdingpen_sort:%s" % (key, ))
rs.delete("holdingpen_sort")
def tearDown(self):
""" Clean up created objects """
from invenio.modules.workflows.models import (BibWorkflowObject,
Workflow,
BibWorkflowEngineLog,
BibWorkflowObjectLog)
from invenio.modules.workflows.utils import get_redis_keys, set_up_redis
workflows = Workflow.get(Workflow.module_name == "unit_tests").all()
for workflow in workflows:
BibWorkflowObject.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid
).delete()
objects = BibWorkflowObjectLog.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid
).all()
for obj in objects:
db.session.delete(obj)
db.session.delete(workflow)
objects = BibWorkflowObjectLog.query.filter(
BibWorkflowObject.id_workflow == workflow.uuid
).all()
for obj in objects:
BibWorkflowObjectLog.delete(id=obj.id)
BibWorkflowEngineLog.delete(uuid=workflow.uuid)
# Deleting dumy object created in tests
db.session.query(BibWorkflowObject).filter(
BibWorkflowObject.id_workflow.in_([11, 123, 253])
).delete(synchronize_session='fetch')
Workflow.query.filter(Workflow.module_name == "unit_tests").delete()
db.session.commit()
rs = set_up_redis()
keys = get_redis_keys()
for key in keys:
keys2 = get_redis_keys(key)
for key2 in keys2:
rs.delete("holdingpen_sort:%s:%s" % (key, key2,))
rs.delete("holdingpen_sort:%s" % (key,))
rs.delete("holdingpen_sort")
def test_deposit_files(self):
from flask import current_app, url_for
from invenio_deposit.loader import \
deposition_metadata
from invenio.modules.workflows.models import Workflow
from invenio.webdeposit_utils import create_workflow, deposit_files, \
get_latest_or_new_workflow
user_id = self.login_user()
# Test for every deposition type
for deposition_type in deposition_metadata.keys():
workflow = create_workflow(deposition_type, user_id)
uuid = workflow.get_uuid()
pdffile = make_pdf_fixture("test.pdf")
with current_app.test_request_context(
url_for(
'webdeposit.upload_file', deposition_type=deposition_type,
uuid=uuid
),
method='POST',
data={
'file': pdffile,
'name': 'test.pdf', }):
deposit_files(user_id, deposition_type, uuid, preingest=True)
workflow = get_latest_or_new_workflow(deposition_type, user_id)
workflow.run()
draft = Workflow.get(
Workflow.id_user == user_id, Workflow.uuid == uuid
).one().extra_data['drafts'][0]
assert len(draft['form_values']['files']) == 1
filemeta = draft['form_values']['files'][0]
assert filemeta['name'] == 'test.pdf'
assert filemeta['content_type'] == 'application/pdf'
def test_deposit_files(self):
from flask import current_app, url_for
from invenio_deposit.loader import \
deposition_metadata
from invenio.modules.workflows.models import Workflow
from invenio.webdeposit_utils import create_workflow, deposit_files, \
get_latest_or_new_workflow
user_id = self.login_user()
# Test for every deposition type
for deposition_type in deposition_metadata.keys():
workflow = create_workflow(deposition_type, user_id)
uuid = workflow.get_uuid()
pdffile = make_pdf_fixture("test.pdf")
with current_app.test_request_context(url_for(
'webdeposit.upload_file',
deposition_type=deposition_type,
uuid=uuid),
method='POST',
data={
'file': pdffile,
'name': 'test.pdf',
}):
deposit_files(user_id, deposition_type, uuid, preingest=True)
workflow = get_latest_or_new_workflow(deposition_type, user_id)
workflow.run()
draft = Workflow.get(
Workflow.id_user == user_id,
Workflow.uuid == uuid).one().extra_data['drafts'][0]
assert len(draft['form_values']['files']) == 1
filemeta = draft['form_values']['files'][0]
assert filemeta['name'] == 'test.pdf'
assert filemeta['content_type'] == 'application/pdf'
def test_record_creation(self):
import os
from wtforms import TextAreaField
from datetime import datetime
from invenio.legacy.search_engine import record_exists
from invenio.cache import cache
from invenio.config import CFG_PREFIX
from invenio.modules.workflows.models import Workflow
from invenio.modules.workflows.config import CFG_WORKFLOW_STATUS
from invenio.modules.scheduler.models import SchTASK
from invenio.webdeposit_utils import get_form, create_workflow, \
set_form_status, CFG_DRAFT_STATUS
from invenio_deposit.loader import \
deposition_metadata
from invenio.webdeposit_workflow_utils import \
create_record_from_marc
from invenio.modules.record.api import get_record
user_id = self.login_user()
for deposition_type in deposition_metadata.keys():
deposition = create_workflow(deposition_type, user_id)
assert deposition is not None
# Check if deposition creates a record
create_rec = create_record_from_marc()
function_exists = False
for workflow_function in deposition.workflow:
if create_rec.func_code == workflow_function .func_code:
function_exists = True
if not function_exists:
# if a record is not created,
# continue with the next deposition
continue
uuid = deposition.get_uuid()
cache.delete_many("1:current_deposition_type", "1:current_uuid")
cache.add("1:current_deposition_type", deposition_type)
cache.add("1:current_uuid", uuid)
# Run the workflow
deposition.run()
# Create form's json based on the field name
form = get_form(user_id, uuid=uuid)
webdeposit_json = {}
# Fill the json with dummy data
for field in form:
if isinstance(field, TextAreaField):
# If the field is associated with a marc field
if field.has_recjson_key() or field.has_cook_function():
webdeposit_json[field.name] = "test " + field.name
draft = dict(form_type=form.__class__.__name__,
form_values=webdeposit_json,
step=0, # dummy step
status=CFG_DRAFT_STATUS['finished'],
timestamp=str(datetime.now()))
# Add a draft for the first step
Workflow.set_extra_data(user_id=user_id, uuid=uuid,
key='drafts', value={0: draft})
workflow_status = CFG_WORKFLOW_STATUS.RUNNING
while workflow_status != CFG_WORKFLOW_STATUS.COMPLETED:
# Continue workflow
deposition.run()
set_form_status(user_id, uuid, CFG_DRAFT_STATUS['finished'])
workflow_status = deposition.get_status()
# Workflow is finished. Test if record is created
recid = deposition.get_data('recid')
assert recid is not None
# Test that record id exists
assert record_exists(recid) == 1
# Test that the task exists
task_id = deposition.get_data('task_id')
assert task_id is not None
bibtask = SchTASK.query.filter(SchTASK.id == task_id).first()
assert bibtask is not None
# Run bibupload, bibindex, webcoll manually
cmd = "%s/bin/bibupload %s" % (CFG_PREFIX, task_id)
assert not os.system(cmd)
rec = get_record(recid)
marc = rec.legacy_export_as_marc()
for field in form:
if isinstance(field, TextAreaField):
# If the field is associated with a marc field
if field.has_recjson_key() or field.has_cook_function():
assert "test " + field.name in marc
def tearDown(self):
"""Clean up tests."""
from invenio.modules.workflows.models import Workflow
Workflow.get(Workflow.module_name == "unit_tests").delete()
self.cleanup_registries()
def test_record_creation(self):
import os
from wtforms import TextAreaField
from datetime import datetime
from invenio.legacy.search_engine import record_exists
from invenio.cache import cache
from invenio.config import CFG_PREFIX
from invenio.modules.workflows.models import Workflow
from invenio.modules.workflows.config import CFG_WORKFLOW_STATUS
from invenio.modules.scheduler.models import SchTASK
from invenio.webdeposit_utils import get_form, create_workflow, \
set_form_status, CFG_DRAFT_STATUS
from invenio_deposit.loader import \
deposition_metadata
from invenio.webdeposit_workflow_utils import \
create_record_from_marc
from invenio.modules.record.api import get_record
user_id = self.login_user()
for deposition_type in deposition_metadata.keys():
deposition = create_workflow(deposition_type, user_id)
assert deposition is not None
# Check if deposition creates a record
create_rec = create_record_from_marc()
function_exists = False
for workflow_function in deposition.workflow:
if create_rec.func_code == workflow_function.func_code:
function_exists = True
if not function_exists:
# if a record is not created,
# continue with the next deposition
continue
uuid = deposition.get_uuid()
cache.delete_many("1:current_deposition_type", "1:current_uuid")
cache.add("1:current_deposition_type", deposition_type)
cache.add("1:current_uuid", uuid)
# Run the workflow
deposition.run()
# Create form's json based on the field name
form = get_form(user_id, uuid=uuid)
webdeposit_json = {}
# Fill the json with dummy data
for field in form:
if isinstance(field, TextAreaField):
# If the field is associated with a marc field
if field.has_recjson_key() or field.has_cook_function():
webdeposit_json[field.name] = "test " + field.name
draft = dict(
form_type=form.__class__.__name__,
form_values=webdeposit_json,
step=0, # dummy step
status=CFG_DRAFT_STATUS['finished'],
timestamp=str(datetime.now()))
# Add a draft for the first step
Workflow.set_extra_data(user_id=user_id,
uuid=uuid,
key='drafts',
value={0: draft})
workflow_status = CFG_WORKFLOW_STATUS.RUNNING
while workflow_status != CFG_WORKFLOW_STATUS.COMPLETED:
# Continue workflow
deposition.run()
set_form_status(user_id, uuid, CFG_DRAFT_STATUS['finished'])
workflow_status = deposition.get_status()
# Workflow is finished. Test if record is created
recid = deposition.get_data('recid')
assert recid is not None
# Test that record id exists
assert record_exists(recid) == 1
# Test that the task exists
task_id = deposition.get_data('task_id')
assert task_id is not None
bibtask = SchTASK.query.filter(SchTASK.id == task_id).first()
assert bibtask is not None
# Run bibupload, bibindex, webcoll manually
cmd = "%s/bin/bibupload %s" % (CFG_PREFIX, task_id)
assert not os.system(cmd)
rec = get_record(recid)
marc = rec.legacy_export_as_marc()
for field in form:
if isinstance(field, TextAreaField):
# If the field is associated with a marc field
if field.has_recjson_key() or field.has_cook_function():
assert "test " + field.name in marc
def tearDown(self):
""" Clean up created objects."""
from invenio.modules.workflows.models import Workflow
self.delete_objects(Workflow.get(Workflow.module_name == "unit_tests").all())
self.cleanup_registries()
def tearDown(self):
""" Clean up created objects."""
from invenio.modules.workflows.models import Workflow
self.delete_objects(
Workflow.get(Workflow.module_name == "unit_tests").all())
self.cleanup_registries()
def tearDown(self):
"""Clean up tests."""
from invenio.modules.workflows.models import Workflow
Workflow.get(Workflow.module_name == "unit_tests").delete()
self.cleanup_registries()
