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 authz_adapter_test_fixture(request):
request.cls.item_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
for bank_ in request.cls.bank_list:
request.cls.item_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = bank_.get_item_form_for_create([])
create_form.display_name = color + ' ' + str(count) + ' Item'
create_form.description = color + ' item for authz adapter tests from Bank number ' + str(
count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
item = bank_.create_item(create_form)
if count == 2 and color == 'Blue':
request.cls.assessment_mgr.assign_item_to_bank(
item.ident, request.cls.bank_id_list[7])
request.cls.item_id_lists[count].append(item.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, bank_ in enumerate(request.cls.bank_list):
for item_id in request.cls.item_id_lists[index]:
bank_.delete_item(item_id)
request.addfinalizer(test_tear_down)
def authz_adapter_test_fixture(request):
request.cls.resource_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
for bin_ in request.cls.bin_list:
request.cls.resource_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = bin_.get_resource_form_for_create([])
create_form.display_name = color + ' ' + str(
count) + ' Resource'
create_form.description = color + ' resource for authz adapter tests from Bin number ' + str(
count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
resource = bin_.create_resource(create_form)
if count == 2 and color == 'Blue':
request.cls.resource_mgr.assign_resource_to_bin(
resource.ident, request.cls.bin_id_list[7])
request.cls.resource_id_lists[count].append(resource.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, bin_ in enumerate(request.cls.bin_list):
for resource_id in request.cls.resource_id_lists[index]:
bin_.delete_resource(resource_id)
request.addfinalizer(test_tear_down)
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_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 authz_adapter_test_fixture(request):
request.cls.comment_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
resource_id = Id(authority='TEST', namespace='resource.Resource', identifier='TEST')
for book_ in request.cls.book_list:
request.cls.comment_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = book_.get_comment_form_for_create(resource_id, [])
create_form.display_name = color + ' ' + str(count) + ' Comment'
create_form.description = color + ' comment for authz adapter tests from Book number ' + str(count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
comment = book_.create_comment(create_form)
if count == 2 and color == 'Blue':
request.cls.commenting_mgr.assign_comment_to_book(
comment.ident,
request.cls.book_id_list[7])
request.cls.comment_id_lists[count].append(comment.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, book_ in enumerate(request.cls.book_list):
for comment_id in request.cls.comment_id_lists[index]:
book_.delete_comment(comment_id)
request.addfinalizer(test_tear_down)
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 authz_adapter_test_fixture(request):
request.cls.objective_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
for objective_bank_ in request.cls.objective_bank_list:
request.cls.objective_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = objective_bank_.get_objective_form_for_create([])
create_form.display_name = color + ' ' + str(count) + ' Objective'
create_form.description = color + ' objective for authz adapter tests from ObjectiveBank number ' + str(count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
objective = objective_bank_.create_objective(create_form)
if count == 2 and color == 'Blue':
request.cls.learning_mgr.assign_objective_to_objective_bank(
objective.ident,
request.cls.objective_bank_id_list[7])
request.cls.objective_id_lists[count].append(objective.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, objective_bank_ in enumerate(request.cls.objective_bank_list):
for objective_id in request.cls.objective_id_lists[index]:
objective_bank_.delete_objective(objective_id)
request.addfinalizer(test_tear_down)
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_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 authz_adapter_test_fixture(request):
request.cls.log_entry_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
for log_ in request.cls.log_list:
request.cls.log_entry_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = log_.get_log_entry_form_for_create([])
create_form.display_name = color + ' ' + str(count) + ' LogEntry'
create_form.description = color + ' log_entry for authz adapter tests from Log number ' + str(count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
log_entry = log_.create_log_entry(create_form)
if count == 2 and color == 'Blue':
request.cls.logging_mgr.assign_log_entry_to_log(
log_entry.ident,
request.cls.log_id_list[7])
request.cls.log_entry_id_lists[count].append(log_entry.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, log_ in enumerate(request.cls.log_list):
for log_entry_id in request.cls.log_entry_id_lists[index]:
log_.delete_log_entry(log_entry_id)
request.addfinalizer(test_tear_down)
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_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 authz_adapter_test_fixture(request):
request.cls.composition_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
for repository_ in request.cls.repository_list:
request.cls.composition_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = repository_.get_composition_form_for_create([])
create_form.display_name = color + ' ' + str(count) + ' Composition'
create_form.description = color + ' composition for authz adapter tests from Repository number ' + str(count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
composition = repository_.create_composition(create_form)
if count == 2 and color == 'Blue':
request.cls.repository_mgr.assign_composition_to_repository(
composition.ident,
request.cls.repository_id_list[7])
request.cls.composition_id_lists[count].append(composition.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, repository_ in enumerate(request.cls.repository_list):
for composition_id in request.cls.composition_id_lists[index]:
repository_.delete_composition(composition_id)
request.addfinalizer(test_tear_down)
def authz_adapter_test_fixture(request):
request.cls.gradebook_column_id_lists = []
count = 0
if not is_never_authz(request.cls.service_config):
for gradebook_ in request.cls.gradebook_list:
request.cls.gradebook_column_id_lists.append([])
for color in ['Red', 'Blue', 'Red']:
create_form = gradebook_.get_gradebook_column_form_for_create(
[])
create_form.display_name = color + ' ' + str(
count) + ' GradebookColumn'
create_form.description = color + ' gradebook_column for authz adapter tests from Gradebook number ' + str(
count)
if color == 'Blue':
create_form.genus_type = BLUE_TYPE
gradebook_column = gradebook_.create_gradebook_column(
create_form)
if count == 2 and color == 'Blue':
request.cls.grading_mgr.assign_gradebook_column_to_gradebook(
gradebook_column.ident,
request.cls.gradebook_id_list[7])
request.cls.gradebook_column_id_lists[count].append(
gradebook_column.ident)
count += 1
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, gradebook_ in enumerate(request.cls.gradebook_list):
for gradebook_column_id in request.cls.gradebook_column_id_lists[
index]:
gradebook_.delete_gradebook_column(gradebook_column_id)
request.addfinalizer(test_tear_down)
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, objective_bank_ in enumerate(
request.cls.objective_bank_list):
for activity_id in request.cls.activity_id_lists[index]:
objective_bank_.delete_activity(activity_id)
request.cls.objective_bank_list[0].delete_objective(
request.cls.objective.ident)
def test_tear_down():
if not is_never_authz(request.cls.service_config):
for index, bank_ in enumerate(request.cls.bank_list):
for assessment_offered_id in request.cls.assessment_offered_id_lists[
index]:
bank_.delete_assessment_offered(assessment_offered_id)
request.cls.bank_list[0].delete_assessment(
request.cls.assessment.ident)
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_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_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 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_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_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_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_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_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_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_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_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()
