def assessment_part_query_class_fixture(request):
request.cls.service_config = request.param
request.cls.assessment_part_list = list()
request.cls.assessment_part_ids = list()
request.cls.svc_mgr = Runtime().get_service_manager(
'ASSESSMENT', proxy=PROXY, implementation=request.cls.service_config)
if not is_never_authz(request.cls.service_config):
create_form = request.cls.svc_mgr.get_bank_form_for_create([])
create_form.display_name = 'Test Bank'
create_form.description = 'Test Bank for AssessmentPartQuery tests'
request.cls.catalog = request.cls.svc_mgr.create_bank(create_form)
assessment_form = request.cls.catalog.get_assessment_form_for_create(
[])
assessment_form.display_name = 'Test Assessment'
assessment_form.description = 'Test Assessment for AssessmentPartQuery tests'
request.cls.assessment = request.cls.catalog.create_assessment(
assessment_form)
def class_tear_down():
if not is_never_authz(request.cls.service_config):
request.cls.catalog.use_unsequestered_assessment_part_view()
request.cls.catalog.delete_assessment(request.cls.assessment.ident)
request.cls.svc_mgr.delete_bank(request.cls.catalog.ident)
request.addfinalizer(class_tear_down)
def comment_class_fixture(request):
request.cls.service_config = request.param
request.cls.svc_mgr = Runtime().get_service_manager(
'COMMENTING',
proxy=PROXY,
implementation=request.cls.service_config)
if not is_never_authz(request.cls.service_config):
create_form = request.cls.svc_mgr.get_book_form_for_create([])
create_form.display_name = 'Test catalog'
create_form.description = 'Test catalog description'
request.cls.catalog = request.cls.svc_mgr.create_book(create_form)
form = request.cls.catalog.get_comment_form_for_create(
Id('resource.Resource%3A1%40ODL.MIT.EDU'),
[])
form.display_name = 'Test object'
request.cls.object = request.cls.catalog.create_comment(form)
def class_tear_down():
if not is_never_authz(request.cls.service_config):
for obj in request.cls.catalog.get_comments():
request.cls.catalog.delete_comment(obj.ident)
request.cls.svc_mgr.delete_book(request.cls.catalog.ident)
request.addfinalizer(class_tear_down)
def test_lookup_log_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_logging_mgr = Runtime().get_service_manager(
'LOGGING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
log = janes_logging_mgr.get_log(self.log_id_list[0])
log.use_federated_log_view()
log.use_comparative_log_entry_view()
# print "START"
assert log.get_log_entries().available() == 13
assert log.get_log_entries_by_genus_type(BLUE_TYPE).available() == 5
for log_entry in log.get_log_entries():
log.get_log_entry(log_entry.ident)
log_entry_ids = [log_entry.ident for log_entry in log.get_log_entries()]
log.get_log_entries_by_ids(log_entry_ids)
for log_entry_id in self.log_entry_id_lists[0]:
with pytest.raises(errors.NotFound):
log_entry = log.get_log_entry(log_entry_id)
log_entry = log.get_log_entry(self.log_entry_id_lists[2][1])
for log_entry_num in [0, 2]:
with pytest.raises(errors.NotFound):
log_entry = log.get_log_entry(self.log_entry_id_lists[2][log_entry_num])
for log_entry_id in self.log_entry_id_lists[1]:
log_entry = log.get_log_entry(log_entry_id)
for log_entry_id in self.log_entry_id_lists[3]:
log_entry = log.get_log_entry(log_entry_id)
for log_entry_id in self.log_entry_id_lists[4]:
log_entry = log.get_log_entry(log_entry_id)
for log_entry_id in self.log_entry_id_lists[5]:
log_entry = log.get_log_entry(log_entry_id)
def authorization_class_fixture(request):
request.cls.service_config = request.param
request.cls.authorization_list = list()
request.cls.authorization_ids = list()
request.cls.svc_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=PROXY,
implementation=request.cls.service_config)
if not is_never_authz(request.cls.service_config):
create_form = request.cls.svc_mgr.get_vault_form_for_create([])
create_form.display_name = 'Test Vault'
create_form.description = 'Test Vault for AuthorizationQuerySession tests'
request.cls.catalog = request.cls.svc_mgr.create_vault(create_form)
create_form = request.cls.catalog.get_authorization_form_for_create_for_agent(
AGENT_ID, LOOKUP_RESOURCE_FUNCTION_ID,
Id(
**{
'identifier': str('foo'),
'namespace': 'resource.Resource',
'authority': 'ODL.MIT.EDU'
}), [])
create_form.display_name = 'Test Authorization'
create_form.description = (
'Test Authorization for Authorization tests')
obj = request.cls.catalog.create_authorization(create_form)
request.cls.object = obj
def class_tear_down():
if not is_never_authz(request.cls.service_config):
for catalog in request.cls.svc_mgr.get_vaults():
for obj in catalog.get_authorizations():
catalog.delete_authorization(obj.ident)
request.cls.svc_mgr.delete_vault(catalog.ident)
request.addfinalizer(class_tear_down)
def test_lookup_bin_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_resource_mgr = Runtime().get_service_manager(
'RESOURCE',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
bin = janes_resource_mgr.get_bin(self.bin_id_list[0])
bin.use_federated_bin_view()
bin.use_comparative_resource_view()
# print "START"
assert bin.get_resources().available() == 13
assert bin.get_resources_by_genus_type(BLUE_TYPE).available() == 5
for resource in bin.get_resources():
bin.get_resource(resource.ident)
resource_ids = [resource.ident for resource in bin.get_resources()]
bin.get_resources_by_ids(resource_ids)
for resource_id in self.resource_id_lists[0]:
with pytest.raises(errors.NotFound):
resource = bin.get_resource(resource_id)
resource = bin.get_resource(self.resource_id_lists[2][1])
for resource_num in [0, 2]:
with pytest.raises(errors.NotFound):
resource = bin.get_resource(
self.resource_id_lists[2][resource_num])
for resource_id in self.resource_id_lists[1]:
resource = bin.get_resource(resource_id)
for resource_id in self.resource_id_lists[3]:
resource = bin.get_resource(resource_id)
for resource_id in self.resource_id_lists[4]:
resource = bin.get_resource(resource_id)
for resource_id in self.resource_id_lists[5]:
resource = bin.get_resource(resource_id)
def test_lookup_repository_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_repository_mgr = Runtime().get_service_manager(
'REPOSITORY',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
repository = janes_repository_mgr.get_repository(self.repository_id_list[0])
repository.use_federated_repository_view()
repository.use_comparative_composition_view()
# print "START"
assert repository.get_compositions().available() == 13
assert repository.get_compositions_by_genus_type(BLUE_TYPE).available() == 5
for composition in repository.get_compositions():
repository.get_composition(composition.ident)
composition_ids = [composition.ident for composition in repository.get_compositions()]
repository.get_compositions_by_ids(composition_ids)
for composition_id in self.composition_id_lists[0]:
with pytest.raises(errors.NotFound):
composition = repository.get_composition(composition_id)
composition = repository.get_composition(self.composition_id_lists[2][1])
for composition_num in [0, 2]:
with pytest.raises(errors.NotFound):
composition = repository.get_composition(self.composition_id_lists[2][composition_num])
for composition_id in self.composition_id_lists[1]:
composition = repository.get_composition(composition_id)
for composition_id in self.composition_id_lists[3]:
composition = repository.get_composition(composition_id)
for composition_id in self.composition_id_lists[4]:
composition = repository.get_composition(composition_id)
for composition_id in self.composition_id_lists[5]:
composition = repository.get_composition(composition_id)
def test_lookup_objective_bank_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_learning_mgr = Runtime().get_service_manager(
'LEARNING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
objective_bank = janes_learning_mgr.get_objective_bank(self.objective_bank_id_list[0])
objective_bank.use_federated_objective_bank_view()
objective_bank.use_comparative_objective_view()
# print "START"
assert objective_bank.get_objectives().available() == 13
assert objective_bank.get_objectives_by_genus_type(BLUE_TYPE).available() == 5
for objective in objective_bank.get_objectives():
objective_bank.get_objective(objective.ident)
objective_ids = [objective.ident for objective in objective_bank.get_objectives()]
objective_bank.get_objectives_by_ids(objective_ids)
for objective_id in self.objective_id_lists[0]:
with pytest.raises(errors.NotFound):
objective = objective_bank.get_objective(objective_id)
objective = objective_bank.get_objective(self.objective_id_lists[2][1])
for objective_num in [0, 2]:
with pytest.raises(errors.NotFound):
objective = objective_bank.get_objective(self.objective_id_lists[2][objective_num])
for objective_id in self.objective_id_lists[1]:
objective = objective_bank.get_objective(objective_id)
for objective_id in self.objective_id_lists[3]:
objective = objective_bank.get_objective(objective_id)
for objective_id in self.objective_id_lists[4]:
objective = objective_bank.get_objective(objective_id)
for objective_id in self.objective_id_lists[5]:
objective = objective_bank.get_objective(objective_id)
def test_lookup_bank_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_assessment_mgr = Runtime().get_service_manager(
'ASSESSMENT',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
bank = janes_assessment_mgr.get_bank(self.bank_id_list[0])
bank.use_federated_bank_view()
bank.use_comparative_item_view()
# print "START"
assert bank.get_items().available() == 13
assert bank.get_items_by_genus_type(BLUE_TYPE).available() == 5
for item in bank.get_items():
bank.get_item(item.ident)
item_ids = [item.ident for item in bank.get_items()]
bank.get_items_by_ids(item_ids)
for item_id in self.item_id_lists[0]:
with pytest.raises(errors.NotFound):
item = bank.get_item(item_id)
item = bank.get_item(self.item_id_lists[2][1])
for item_num in [0, 2]:
with pytest.raises(errors.NotFound):
item = bank.get_item(self.item_id_lists[2][item_num])
for item_id in self.item_id_lists[1]:
item = bank.get_item(item_id)
for item_id in self.item_id_lists[3]:
item = bank.get_item(item_id)
for item_id in self.item_id_lists[4]:
item = bank.get_item(item_id)
for item_id in self.item_id_lists[5]:
item = bank.get_item(item_id)
def test_lookup_vault_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_authorization_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
vault = janes_authorization_mgr.get_vault(self.vault_id_list[0])
vault.use_federated_vault_view()
vault.use_comparative_authorization_view()
# print "START"
assert vault.get_authorizations().available() == 13
assert vault.get_authorizations_by_genus_type(BLUE_TYPE).available() == 5
for authorization in vault.get_authorizations():
vault.get_authorization(authorization.ident)
authorization_ids = [authorization.ident for authorization in vault.get_authorizations()]
vault.get_authorizations_by_ids(authorization_ids)
for authorization_id in self.authorization_id_lists[0]:
with pytest.raises(errors.NotFound):
authorization = vault.get_authorization(authorization_id)
authorization = vault.get_authorization(self.authorization_id_lists[2][1])
for authorization_num in [0, 2]:
with pytest.raises(errors.NotFound):
authorization = vault.get_authorization(self.authorization_id_lists[2][authorization_num])
for authorization_id in self.authorization_id_lists[1]:
authorization = vault.get_authorization(authorization_id)
for authorization_id in self.authorization_id_lists[3]:
authorization = vault.get_authorization(authorization_id)
for authorization_id in self.authorization_id_lists[4]:
authorization = vault.get_authorization(authorization_id)
for authorization_id in self.authorization_id_lists[5]:
authorization = vault.get_authorization(authorization_id)
def test_lookup_book_0_comparative_federated(self):
if not is_never_authz(self.service_config):
janes_commenting_mgr = Runtime().get_service_manager(
'COMMENTING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
book = janes_commenting_mgr.get_book(self.book_id_list[0])
book.use_federated_book_view()
book.use_comparative_comment_view()
# print "START"
assert book.get_comments().available() == 13
assert book.get_comments_by_genus_type(BLUE_TYPE).available() == 5
for comment in book.get_comments():
book.get_comment(comment.ident)
comment_ids = [comment.ident for comment in book.get_comments()]
book.get_comments_by_ids(comment_ids)
for comment_id in self.comment_id_lists[0]:
with pytest.raises(errors.NotFound):
comment = book.get_comment(comment_id)
comment = book.get_comment(self.comment_id_lists[2][1])
for comment_num in [0, 2]:
with pytest.raises(errors.NotFound):
comment = book.get_comment(self.comment_id_lists[2][comment_num])
for comment_id in self.comment_id_lists[1]:
comment = book.get_comment(comment_id)
for comment_id in self.comment_id_lists[3]:
comment = book.get_comment(comment_id)
for comment_id in self.comment_id_lists[4]:
comment = book.get_comment(comment_id)
for comment_id in self.comment_id_lists[5]:
comment = book.get_comment(comment_id)
def test_lookup_gradebook_0_plenary_federated(self):
if not is_never_authz(self.service_config):
janes_grading_mgr = Runtime().get_service_manager(
'GRADING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
gradebook = janes_grading_mgr.get_gradebook(
self.gradebook_id_list[0])
gradebook.use_federated_gradebook_view()
gradebook.use_plenary_gradebook_column_view()
assert gradebook.can_lookup_gradebook_columns()
assert gradebook.get_gradebook_columns().available() == 1
assert gradebook.get_gradebook_columns_by_genus_type(
BLUE_TYPE).available() == 1
assert gradebook.get_gradebook_columns_by_genus_type(
BLUE_TYPE).next().ident == self.gradebook_column_id_lists[2][1]
gradebook.get_gradebook_column(
self.gradebook_column_id_lists[2][1])
for gradebook_column_num in [0, 2]:
with pytest.raises(
errors.NotFound
): # Is this right? Perhaps PermissionDenied
gradebook_column = gradebook.get_gradebook_column(
self.gradebook_column_id_lists[2]
[gradebook_column_num])
def test_lookup_log_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_logging_mgr = Runtime().get_service_manager(
'LOGGING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
log = janes_logging_mgr.get_log(self.log_id_list[0])
log.use_isolated_log_view()
log.use_plenary_log_entry_view()
def test_lookup_repository_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_repository_mgr = Runtime().get_service_manager(
'REPOSITORY',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
repository = janes_repository_mgr.get_repository(self.repository_id_list[0])
repository.use_isolated_repository_view()
repository.use_plenary_composition_view()
def test_lookup_bin_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_resource_mgr = Runtime().get_service_manager(
'RESOURCE',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
bin = janes_resource_mgr.get_bin(self.bin_id_list[0])
bin.use_isolated_bin_view()
bin.use_plenary_resource_view()
def test_lookup_book_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_commenting_mgr = Runtime().get_service_manager(
'COMMENTING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
book = janes_commenting_mgr.get_book(self.book_id_list[0])
book.use_isolated_book_view()
book.use_plenary_comment_view()
def test_lookup_vault_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_authorization_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
vault = janes_authorization_mgr.get_vault(self.vault_id_list[0])
vault.use_isolated_vault_view()
vault.use_plenary_authorization_view()
def test_lookup_bank_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_assessment_mgr = Runtime().get_service_manager(
'ASSESSMENT',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
bank = janes_assessment_mgr.get_bank(self.bank_id_list[0])
bank.use_isolated_bank_view()
bank.use_plenary_assessment_offered_view()
def test_lookup_objective_bank_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_learning_mgr = Runtime().get_service_manager(
'LEARNING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
objective_bank = janes_learning_mgr.get_objective_bank(self.objective_bank_id_list[0])
objective_bank.use_isolated_objective_bank_view()
objective_bank.use_plenary_objective_view()
def log_form_class_fixture(request):
# From test_templates/resource.py::BinForm::init_template
request.cls.service_config = request.param
request.cls.svc_mgr = Runtime().get_service_manager(
'LOGGING', proxy=PROXY, implementation=request.cls.service_config)
def class_tear_down():
pass
request.addfinalizer(class_tear_down)
def test_query_vault_0_isolated(self):
if not is_never_authz(self.service_config):
janes_authorization_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
vault = janes_authorization_mgr.get_vault(self.vault_id_list[0])
vault.use_isolated_vault_view()
with pytest.raises(errors.PermissionDenied):
query = vault.get_authorization_query()
def test_query_book_0_isolated(self):
if not is_never_authz(self.service_config):
janes_commenting_mgr = Runtime().get_service_manager(
'COMMENTING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
book = janes_commenting_mgr.get_book(self.book_id_list[0])
book.use_isolated_book_view()
with pytest.raises(errors.PermissionDenied):
query = book.get_comment_query()
def test_query_bank_0_isolated(self):
if not is_never_authz(self.service_config):
janes_assessment_mgr = Runtime().get_service_manager(
'ASSESSMENT',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
bank = janes_assessment_mgr.get_bank(self.bank_id_list[0])
bank.use_isolated_bank_view()
with pytest.raises(errors.PermissionDenied):
query = bank.get_assessment_offered_query()
def test_query_objective_bank_0_isolated(self):
if not is_never_authz(self.service_config):
janes_learning_mgr = Runtime().get_service_manager(
'LEARNING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
objective_bank = janes_learning_mgr.get_objective_bank(self.objective_bank_id_list[0])
objective_bank.use_isolated_objective_bank_view()
with pytest.raises(errors.PermissionDenied):
query = objective_bank.get_objective_query()
def test_query_bin_0_isolated(self):
if not is_never_authz(self.service_config):
janes_resource_mgr = Runtime().get_service_manager(
'RESOURCE',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
bin = janes_resource_mgr.get_bin(self.bin_id_list[0])
bin.use_isolated_bin_view()
with pytest.raises(errors.PermissionDenied):
query = bin.get_resource_query()
def test_query_repository_0_isolated(self):
if not is_never_authz(self.service_config):
janes_repository_mgr = Runtime().get_service_manager(
'REPOSITORY',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
repository = janes_repository_mgr.get_repository(self.repository_id_list[0])
repository.use_isolated_repository_view()
with pytest.raises(errors.PermissionDenied):
query = repository.get_composition_query()
def test_query_log_0_isolated(self):
if not is_never_authz(self.service_config):
janes_logging_mgr = Runtime().get_service_manager(
'LOGGING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
log = janes_logging_mgr.get_log(self.log_id_list[0])
log.use_isolated_log_view()
with pytest.raises(errors.PermissionDenied):
query = log.get_log_entry_query()
def test_lookup_gradebook_0_plenary_isolated(self):
if not is_never_authz(self.service_config):
janes_grading_mgr = Runtime().get_service_manager(
'GRADING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
gradebook = janes_grading_mgr.get_gradebook(
self.gradebook_id_list[0])
gradebook.use_isolated_gradebook_view()
gradebook.use_plenary_gradebook_column_view()
def test_query_vault_1_federated(self):
if not is_never_authz(self.service_config):
janes_authorization_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
vault = janes_authorization_mgr.get_vault(self.vault_id_list[1])
vault.use_federated_vault_view()
query = vault.get_authorization_query()
query.match_display_name('red')
assert vault.get_authorizations_by_query(query).available() == 6
def test_lookup_vault_3_comparative_isolated(self):
if not is_never_authz(self.service_config):
janes_authorization_mgr = Runtime().get_service_manager(
'AUTHORIZATION',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
vault = janes_authorization_mgr.get_vault(self.vault_id_list[3])
vault.use_isolated_vault_view()
vault.use_comparative_authorization_view()
assert vault.get_authorizations().available() == 3
assert vault.get_authorizations_by_genus_type(BLUE_TYPE).available() == 1
def test_query_objective_bank_1_federated(self):
if not is_never_authz(self.service_config):
janes_learning_mgr = Runtime().get_service_manager(
'LEARNING',
proxy=JANE_PROXY,
implementation='TEST_SERVICE_JSON_AUTHZ')
objective_bank = janes_learning_mgr.get_objective_bank(self.objective_bank_id_list[1])
objective_bank.use_federated_objective_bank_view()
query = objective_bank.get_objective_query()
query.match_display_name('red')
assert objective_bank.get_objectives_by_query(query).available() == 6
