def mixed_exclude_helper(self, strict):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('A')
observation.add_object('B')
observation.add_object('C')
fake_observer = FakeObserver(observation)
# We dont expect to see B in the list.
# This can be interpreted two ways -- strictly or not strictly.
# Strictly means no results should ever contain B.
# Non strict means some result should not contain B.
builder = jc.ValueObservationVerifierBuilder('Test Excludes',
strict=strict)
builder.excludes_path_value(None, 'B')
clause = jc.ContractClause('TestClause', fake_observer,
builder.build())
contract = jc.Contract()
contract.add_clause(clause)
# Doesnt matter whether strict or not since this is checking cardinality
# over the entire list via the excludes clause.
expect_result = jc.contract.ContractVerifyResult(
False, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertEqual(False, result.valid)
def test_assertContract_failed(self):
context = ExecutionContext()
verifier = FakeVerifier(False)
clause = jc.ContractClause(
'TestClause', observer=FakeObserver(), verifier=verifier)
contract = jc.Contract()
contract.add_clause(clause)
self.assertRaises(AssertionError, self.assertContract, context, contract)
def test_assertContract_ok(self):
context = ExecutionContext()
verifier = FakeVerifier(True)
clause = jc.ContractClause(
'TestClause', observer=FakeObserver(), verifier=verifier)
contract = jc.Contract()
contract.add_clause(clause)
self.assertContract(context, contract)
def _do_run_test_case(self, succeed, with_callbacks, with_context):
# pylint: disable=unused-argument
operation = FakeOperation('TestOperation', self.testing_agent)
verifier = FakeVerifier(succeed)
clause = jc.ContractClause('TestClause',
observer=FakeObserver(),
verifier=verifier)
contract = jc.Contract()
contract.add_clause(clause)
class HelperClass(object):
"""Need to share state between these helper methods and outer scope.
This class provides the functions we are going to inject, along
with state we can check in the outer scope.
"""
cleanup_calls = 0
execution_context = ExecutionContext() if with_context else None
@staticmethod
def status_extractor(status, context):
if with_context:
# Verify this is the context we injected.
self.assertEquals(HelperClass.execution_context, context)
self.assertIsNotNone(context.get('OperationStatus', None))
self.assertIsNone(context.get('GOT_STATUS', None))
context['GOT_STATUS'] = status
@staticmethod
def cleanup(context):
self.assertIsNotNone(context.get('OperationStatus', None))
self.assertEquals(context.get('OperationStatus', None),
context.get('GOT_STATUS', None))
HelperClass.cleanup_calls += 1
status_extractor = HelperClass.status_extractor
cleanup = HelperClass.cleanup
operation_contract = st.OperationContract(
operation,
contract,
status_extractor=status_extractor,
cleanup=cleanup)
if succeed:
self.run_test_case(operation_contract,
context=HelperClass.execution_context)
else:
self.assertRaises(AssertionError,
self.run_test_case,
operation_contract,
context=HelperClass.execution_context)
self.assertEquals(1, HelperClass.cleanup_calls)
def test_clause_failure(self):
observation = jc.Observation()
observation.add_object('B')
fake_observer = FakeObserver(observation)
eq_A = jp.STR_EQ('A')
verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A])
clause = jc.ContractClause('TestClause', fake_observer, verifier)
expect_result = jc.contract.ContractClauseVerifyResult(
False, clause, verifier(observation))
result = clause.verify()
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_clause_success(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('A')
fake_observer = FakeObserver(observation)
eq_A = jp.STR_EQ('A')
verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A])
clause = jc.ContractClause('TestClause', fake_observer, verifier)
expect_result = jc.contract.ContractClauseVerifyResult(
True, clause, verifier(context, observation))
result = clause.verify(context)
self.assertEqual(expect_result, result)
self.assertTrue(result)
def test_clause_failure(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('B')
fake_observer = FakeObserver(observation)
eq_A = jp.LIST_MATCHES([jp.STR_EQ('A')])
verifier = jc.ValueObservationVerifierBuilder('Has A').EXPECT(
eq_A).build()
clause = jc.ContractClause('TestClause', fake_observer, verifier)
expect_result = jc.contract.ContractClauseVerifyResult(
False, clause, verifier(context, observation))
result = clause.verify(context)
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_contract_success(self):
observation = jc.Observation()
observation.add_object('A')
fake_observer = FakeObserver(observation)
eq_A = jp.STR_EQ('A')
verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A])
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
True, [clause.verify()])
result = contract.verify()
self.assertEqual(expect_result, result)
self.assertTrue(result)
def test_contract_failure(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('B')
fake_observer = FakeObserver(observation)
eq_A = jp.STR_EQ('A')
verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A])
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
False, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_contract_observation_failure(self):
observation = jc.Observation()
observation.add_error(
jp.PredicateResult(False, comment='Observer Failed'))
fake_observer = FakeObserver(observation)
eq_A = jp.STR_EQ('A')
verifier = jc.ValueObservationVerifier('Has A', constraints=[eq_A])
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
False, [clause.verify()])
result = contract.verify()
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_contract_success(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('A')
fake_observer = FakeObserver(observation)
eq_A = jp.LIST_MATCHES([jp.STR_EQ('A')])
verifier = jc.ValueObservationVerifierBuilder('Has A').EXPECT(
eq_A).build()
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
True, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertTrue(result)
def test_contract_mixed_clause_failure_not_ok(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('A')
fake_observer = FakeObserver(observation)
verifier = (
jc.ValueObservationVerifierBuilder('Has A and B').contains_match(
[jp.STR_EQ('A'), jp.STR_EQ('B')]).build())
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
False, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_contract_mixed_clause_failure_not_ok(self):
observation = jc.Observation()
observation.add_object('A')
fake_observer = FakeObserver(observation)
eq_A = jp.STR_EQ('A')
eq_B = jp.STR_EQ('B')
verifier = jc.ValueObservationVerifier('Has A and B',
constraints=[eq_A, eq_B])
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
False, [clause.verify()])
result = contract.verify()
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_contract_observation_failure(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_error(
jp.PredicateResult(False, comment='Observer Failed'))
fake_observer = FakeObserver(observation)
eq_A = jp.LIST_MATCHES([jp.STR_EQ('A')])
verifier = jc.ValueObservationVerifierBuilder('Has A').EXPECT(
eq_A).build()
clause = jc.ContractClause('TestClause', fake_observer, verifier)
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
False, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertFalse(result)
def test_multiple_required(self):
context = ExecutionContext()
observation = jc.Observation()
observation.add_object('A')
observation.add_object('B')
observation.add_object('C')
fake_observer = FakeObserver(observation)
eq_A_or_B = jp.OR([jp.STR_EQ('A'), jp.STR_EQ('B')])
builder = jc.ValueObservationVerifierBuilder('Test Multiple')
builder.contains_path_pred(None, eq_A_or_B, min=2)
clause = jc.ContractClause('TestClause', fake_observer, builder.build())
contract = jc.Contract()
contract.add_clause(clause)
expect_result = jc.contract.ContractVerifyResult(
True, [clause.verify(context)])
result = contract.verify(context)
self.assertEqual(expect_result, result)
self.assertEqual(True, result.valid)
def destroy_app(self):
contract = jc.Contract()
app_path = os.path.join('/default/applications/name', self.TEST_APP)
obs_builder = jc.ObservationVerifierBuilder('Removed Application')
obs_builder.append_verifier(
st.HttpObservationFailureVerifier('Not Found', 404))
f50_observer = st.HttpObjectObserver(self.agent, app_path)
f50_clause = jc.ContractClause(title='Deleted Application',
observer=f50_observer,
verifier=obs_builder.build())
contract.add_clause(f50_clause)
gcs_builder = gcp.GoogleCloudStorageContractBuilder(self.gcs_observer)
(gcs_builder.new_clause_builder('Deleted File').list(
self.BUCKET_ROOT,
'applications').excludes_path_value('name', self.TEST_APP))
for clause in gcs_builder.build().clauses:
contract.add_clause(clause)
path = os.path.join('/default/applications/name/', self.TEST_APP)
return st.OperationContract(self.new_delete_operation(
title='delete_app', data=None, path=path),
contract=contract)
