def test_categorize_donor(self, ultsys_user_function): # pylint: disable=unused-argument
"""The caging process categorizes donors as new, exists, cage, or caged. This function tests this process."""
with self.app.app_context():
# Use an existing user so category is exists.
category = categorize_donor(
flatten_user_dict(get_exists_donor_dict()))
self.assertEqual(category[0], 'exists')
# Use a caged donor so category is caged.
caged_donor_dict = get_caged_donor_dict(
{'gift_searchable_id': uuid.uuid4()})
caged_donor = from_json(CagedDonorSchema(), caged_donor_dict)
database.session.add(caged_donor.data)
database.session.commit()
category = categorize_donor(caged_donor_dict)
self.assertEqual(category[0], 'caged')
# Use the existing user, change the name so category is cage.
cage_donor = copy.deepcopy(get_exists_donor_dict())
cage_donor['user_address']['user_first_name'] = 'Sherry'
category = categorize_donor(flatten_user_dict(cage_donor))
self.assertEqual(category[0], 'cage')
# Get a new donor so category is new.
category = categorize_donor(flatten_user_dict(
get_new_donor_dict()))
self.assertEqual(category[0], 'new')
def test_caged_donor_model(self):
"""A test to ensure that caged donors are saved correctly to the database."""
with self.app.app_context():
caged_donor_dict = get_caged_donor_dict({
'gift_id':
1,
'gift_searchable_id':
uuid.uuid4(),
'customer_id':
'customer_id'
})
caged_donor_model = from_json(CagedDonorSchema(),
caged_donor_dict,
create=True)
database.session.add(caged_donor_model.data)
database.session.commit()
caged_donor_query = CagedDonorModel.query\
.filter_by( customer_id=caged_donor_dict[ 'customer_id' ] ).one()
caged_donor_session = database.session.query( CagedDonorModel )\
.filter_by( customer_id=caged_donor_dict[ 'customer_id' ] ).one()
kwargs = {
'self': self,
'model_dict': caged_donor_dict,
'model': CagedDonorModel,
'model_data': caged_donor_model.data,
'model_query': caged_donor_query,
'model_session': caged_donor_session
}
ensure_query_session_aligned(kwargs)
def test_caged_donors(self):
"""Caged donor API ( methods = [ GET ] )."""
with self.app.app_context():
url = '/donation/donors/caged'
# Ensure a GET with no saved caged_donors returns 0.
response = self.test_client.get(url, headers=self.headers)
self.assertEqual(len(json.loads(response.data.decode('utf-8'))), 0)
# Create some caged_donors to retrieve.
total_caged_donors = 5
caged_donor_models = create_model_list(CagedDonorSchema(),
get_caged_donor_dict(),
total_caged_donors)
database.session.bulk_save_objects(caged_donor_models)
database.session.commit()
# Ensure GET returns all caged_donors.
response = self.test_client.get(url, headers=self.headers)
self.assertEqual(len(json.loads(response.data.decode('utf-8'))),
total_caged_donors)
def create_database_tables():
"""Function to create the DONATE database tables, specifically the CagedDonorModel and QueuedDonorModel with UUID.
All that is said here for the CagedDonorModel also holds for the QueuedDonorModel. The CagedDonorModel is built
using Marshmallow schema CagedDonorSchema, which deserializes a dictionary to the model. The searchable_id in the
donor_json is:
donor_json[ 'searchable_id' ] = uuid.uuid4()
This gets passed to the CagedDonorSchema where:
searchable_id = fields.UUID()
And so the validation step is passed.
MySql does not have a UUID type though and there we have ( CagedDonorModel ):
searchable_id = database.Column( database.BINARY( 16 ), nullable=False, default=uuid.uuid4().bytes )
The helper model class BinaryUUID in binary_uuid.py handles the serialization in and out.
"""
with app.app_context():
drop_all_and_create()
caged_donors = []
queued_donors = []
# Create 100 caged donors.
for i in range(0, 100):
donor_json = get_caged_donor_dict(
{'gift_searchable_id': uuid.uuid4()})
donor_json['gift_id'] = i + 1
donor_json['customer_id'] = str((i + 1) + 1000)
del donor_json['id']
caged_donor = CagedDonorSchema().load(donor_json).data
queued_donor = QueuedDonorSchema().load(donor_json).data
caged_donors.append(caged_donor)
queued_donors.append(queued_donor)
# Create the agents.
agent_jsons = [{
'name': 'Donate API',
'user_id': None,
'staff_id': None,
'type': 'Automated'
}, {
'name': 'Braintree',
'user_id': None,
'staff_id': None,
'type': 'Organization'
}, {
'name': 'PayPal',
'user_id': None,
'staff_id': None,
'type': 'Organization'
}, {
'name': 'Credit Card Issuer',
'user_id': None,
'staf_id': None,
'type': 'Organization'
}, {
'name': 'Unspecified NumbersUSA Staff',
'user_id': None,
'staff_id': None,
'type': 'Staff Member'
}, {
'name': 'Dan Marsh',
'user_id': 1234,
'staff_id': 4321,
'type': 'Staff Member'
}, {
'name': 'Joshua Turcotte',
'user_id': 7041,
'staff_id': 1407,
'type': 'Staff Member'
}, {
'name': 'Donate API',
'user_id': None,
'staff_id': None,
'type': 'Automated'
}]
agents = []
for agent_json in agent_jsons:
agent_model = AgentSchema().load(agent_json).data
agents.append(agent_model)
database.session.bulk_save_objects(caged_donors)
database.session.bulk_save_objects(queued_donors)
database.session.bulk_save_objects(agents)
database.session.commit()
def test_admin_caged_donor(self, ultsys_user_function,
mock_caging_function): # pylint: disable=unused-argument
"""Test the administrative donation of a donor who has been previously caged."""
with self.app.app_context():
agent_dict = get_agent_dict(
{'name': 'Unspecified NumbersUSA Staff'})
agent_model = from_json(AgentSchema(), agent_dict, create=True)
database.session.add(agent_model.data)
database.session.flush()
database.session.commit()
agent_dict = get_agent_dict({'name': 'Fidelity Bank'})
bank_agent_model = from_json(AgentSchema(),
agent_dict,
create=True)
database.session.add(bank_agent_model.data)
database.session.flush()
database.session.commit()
# Create the agent who will be referenced in the payload.
agent_user_id = '3255162'
agent_dict = get_agent_dict({
'name': 'Aaron Peters',
'user_id': agent_user_id,
'type': 'Staff Member'
})
user_agent_model = from_json(AgentSchema(),
agent_dict,
create=True)
database.session.add(user_agent_model.data)
database.session.flush()
database.session.commit()
# Create a caged donor, which will be caged again.
caged_donor_dict = get_caged_donor_dict({
'gift_searchable_id':
uuid.uuid4(),
'customer_id':
self.parameters['customer_id']
})
caged_donor_model = from_json(CagedDonorSchema(),
caged_donor_dict,
create=True)
database.session.add(caged_donor_model.data)
database.session.flush()
database.session.commit()
# Call function to tests.
payload = get_donate_dict({
'gift': {
'method_used': self.parameters['method_used'],
'date_of_method_used':
self.parameters['date_of_method_used']
},
'user': {
'user_address': {
'user_first_name':
caged_donor_model.data.user_first_name,
'user_last_name':
caged_donor_model.data.user_last_name,
'user_address': caged_donor_model.data.user_address
}
}
})
payload['sourced_from_agent_user_id'] = agent_user_id
payload['transaction']['reference_number'] = self.parameters[
'reference_number']
payload['transaction']['type'] = self.parameters[
'transaction_type']
self.assertEqual(
post_donation(payload)['job_id'], 'redis-queue-job-id')
# The function should create one transaction, a gift, and a user.
transactions = TransactionModel.query.all()
gift = GiftModel.query.filter_by(id=1).one_or_none()
self.assertEqual(transactions[0].gift_id, gift.id)
self.assertEqual(transactions[0].enacted_by_agent_id, 3)
self.assertEqual(transactions[0].type,
self.parameters['transaction_type'])
self.assertEqual(transactions[0].status,
self.parameters['transaction_status'])
self.assertEqual(transactions[0].reference_number,
self.parameters['reference_number'])
self.assertEqual(transactions[0].gross_gift_amount,
self.parameters['gross_gift_amount'])
self.assertEqual(transactions[1].gift_id, gift.id)
self.assertEqual(transactions[1].enacted_by_agent_id, 2)
self.assertEqual(transactions[1].type,
self.parameters['second_transaction_type'])
self.assertEqual(transactions[1].status,
self.parameters['transaction_status'])
self.assertEqual(transactions[1].reference_number,
self.parameters['bank_deposit_number'])
self.assertEqual(transactions[1].gross_gift_amount,
self.parameters['gross_gift_amount'])
caged_donor = CagedDonorModel.query.filter_by(id=2).one()
self.assertEqual(caged_donor.gift_searchable_id,
gift.searchable_id)
self.assertEqual(caged_donor.user_first_name,
caged_donor_dict['user_first_name'])
self.assertEqual(caged_donor.user_last_name,
caged_donor_dict['user_last_name'])
def test_admin_cage_donor(self, ultsys_user_function,
mock_caging_function): # pylint: disable=unused-argument
"""Test the administrative donation of a donor who has to be caged."""
with self.app.app_context():
# Create the sourced by agent.
agent_dict = get_agent_dict(
{'name': 'Unspecified NumbersUSA Staff'})
agent_model = from_json(AgentSchema(), agent_dict, create=True)
database.session.add(agent_model.data)
database.session.flush()
database.session.commit()
agent_dict = get_agent_dict({'name': 'Fidelity Bank'})
bank_agent_model = from_json(AgentSchema(),
agent_dict,
create=True)
database.session.add(bank_agent_model.data)
database.session.flush()
database.session.commit()
# Create the agent who will be referenced in the payload.
agent_user_id = '3255162'
agent_dict = get_agent_dict({
'name': 'Aaron Peters',
'user_id': agent_user_id,
'type': 'Staff Member'
})
user_agent_model = from_json(AgentSchema(),
agent_dict,
create=True)
database.session.add(user_agent_model.data)
database.session.flush()
database.session.commit()
# Call the function to be tested.
# Administrative donations need to provide information not required by an online donation.
payload = get_donate_dict({
'gift': {
'method_used': self.parameters['method_used'],
},
'transaction': {
'date_of_method_used':
self.parameters['date_of_method_used']
},
'user': {
'user_address': {
'user_first_name': 'Alice',
'user_email_address': '*****@*****.**'
},
'billing_address': {}
},
'recurring_subscription': False
})
payload['sourced_from_agent_user_id'] = agent_user_id
payload['transaction']['reference_number'] = self.parameters[
'reference_number']
payload['transaction']['type'] = self.parameters[
'transaction_type']
self.assertEqual(
post_donation(payload)['job_id'], 'redis-queue-job-id')
# The function should create one transaction, a gift, and a user.
transactions = TransactionModel.query.all()
gift = GiftModel.query.filter_by(id=1).one_or_none()
self.assertEqual(transactions[0].gift_id, gift.id)
self.assertEqual(transactions[0].enacted_by_agent_id, 3)
self.assertEqual(transactions[0].type,
self.parameters['transaction_type'])
self.assertEqual(transactions[0].status,
self.parameters['transaction_status'])
self.assertEqual(transactions[0].reference_number,
self.parameters['reference_number'])
self.assertEqual(transactions[0].gross_gift_amount,
self.parameters['gross_gift_amount'])
self.assertEqual(transactions[1].gift_id, gift.id)
self.assertEqual(transactions[1].enacted_by_agent_id, 2)
self.assertEqual(transactions[1].type,
self.parameters['second_transaction_type'])
self.assertEqual(transactions[1].status,
self.parameters['transaction_status'])
self.assertEqual(transactions[1].reference_number,
self.parameters['bank_deposit_number'])
self.assertEqual(transactions[1].gross_gift_amount,
self.parameters['gross_gift_amount'])
caged_donor_dict = get_caged_donor_dict()
caged_donor = CagedDonorModel.query.first()
self.assertEqual(caged_donor.gift_searchable_id,
gift.searchable_id)
self.assertEqual(caged_donor.user_first_name,
caged_donor_dict['user_first_name'])
self.assertEqual(caged_donor.user_last_name,
caged_donor_dict['user_last_name'])
def test_donation_caged_donor(self, ultsys_user_function,
mock_caging_function): # pylint: disable=unused-argument
"""Test Braintree sale for a donor that has already been caged.
:param ultsys_user_function: Argument for mocked function.
:return:
"""
with self.app.app_context():
# Create agent ( Braintree ) for the online donation.
agent_dict = get_agent_dict()
agent_model = from_json(AgentSchema(), agent_dict, create=True)
database.session.add(agent_model.data)
# Flush to get agent ID and set database.
database.session.flush()
agent_id = agent_model.data.id
# Create a caged donor, which will be caged again.
caged_donor_dict = get_caged_donor_dict({
'gift_searchable_id':
uuid.uuid4(),
'customer_id':
self.parameters['customer_id']
})
caged_donor_model = from_json(CagedDonorSchema(), caged_donor_dict)
database.session.add(caged_donor_model.data)
database.session.commit()
# Call function to tests.
payload = get_donate_dict({
'user': {
'user_address': {
'user_first_name': 'Alice',
'user_email_address': '*****@*****.**'
},
'billing_address': {}
},
'recurring_subscription': False
})
result = post_donation(payload)
self.assertEqual(result['job_id'], 'redis-queue-job-id')
# The function should create one transaction, a gift, and an additional caged donor.
# Additional caged donor is the same as first, but attached to a separate gift.
transaction = TransactionModel.query.filter_by(id=1).one_or_none()
gift = GiftModel.query.filter_by(id=1).one_or_none()
caged_donor = CagedDonorModel.query.filter_by(id=2).one_or_none()
self.assertEqual(transaction.gift_id, gift.id)
self.assertEqual(transaction.enacted_by_agent_id, agent_id)
self.assertEqual(transaction.type,
self.parameters['transaction_type'])
self.assertEqual(transaction.status,
self.parameters['transaction_status'])
self.assertEqual(transaction.reference_number,
self.parameters['reference_number'])
self.assertEqual(transaction.gross_gift_amount,
self.parameters['gross_gift_amount'])
self.assertEqual(transaction.fee, self.parameters['fee'])
self.assertEqual(gift.user_id, -1)
self.assertEqual(gift.method_used_id, self.method_used_id)
self.assertEqual(gift.given_to, self.parameters['given_to'])
self.assertEqual(caged_donor.gift_searchable_id,
gift.searchable_id)
self.assertEqual(caged_donor.customer_id,
self.parameters['customer_id'])
self.assertEqual(caged_donor.user_first_name,
caged_donor_dict['user_first_name'])
self.assertEqual(caged_donor.user_last_name,
caged_donor_dict['user_last_name'])