def get(self, zero_or_one):
"""Endpoint to retrieve campaigns by active or inactive."""
campaigns = get_campaigns_by_type('is_active', zero_or_one)
if campaigns or campaigns == []:
schema = CampaignSchema(many=True)
return schema.dump(campaigns).data
return None, status.HTTP_500_INTERNAL_SERVER_ERROR
def get(self, campaign_id):
"""Endpoint to retrieve campaign its id."""
campaign = get_campaign_by_id(campaign_id)
if campaign:
schema = CampaignSchema()
result = schema.dump(campaign).data
return result, status.HTTP_200_OK
if not campaign:
return None, status.HTTP_404_NOT_FOUND
return None, status.HTTP_500_INTERNAL_SERVER_ERROR
def test_campaign_model(self):
"""A test to ensure that campaigns are saved correctly to the database."""
with self.app.app_context():
campaign_dict = get_campaign_dict()
campaign_model = from_json(CampaignSchema(),
campaign_dict,
create=True)
database.session.add(campaign_model.data)
database.session.commit()
campaign_query = CampaignModel.query.filter_by(
name=campaign_dict['name']).one()
campaign_session = database.session.query( CampaignModel )\
.filter_by( name=campaign_dict[ 'name' ] ).one()
kwargs = {
'self': self,
'model_dict': campaign_dict,
'model': CampaignModel,
'model_data': campaign_model.data,
'model_query': campaign_query,
'model_session': campaign_session
}
ensure_query_session_aligned(kwargs)
def test_get_campaign_amounts( self ):
"""Retrieve the Campaign amounts given its ID ( methods = [ GET ] )."""
with self.app.app_context():
url = '/donation/campaigns/2/amounts'
# Endpoint will check to see that the campaign exists before retrieving amounts and so create a few.
total_campaigns = 4
campaign_models = create_model_list(
CampaignSchema(), get_campaign_dict(), total_campaigns
)
database.session.bulk_save_objects( campaign_models )
campaign_amounts_dict = get_campaign_amount_jsons()
campaign_amount_models = [ ]
for amount in campaign_amounts_dict:
campaign_amount_models.append( from_json( CampaignAmountsSchema(), amount ).data )
database.session.bulk_save_objects( campaign_amount_models )
database.session.commit()
response = self.test_client.get( url, headers=self.headers )
amounts_returned = json.loads( response.data.decode( 'utf-8' ) )
self.assertEqual( len( amounts_returned ), 3 )
def build_campaign_model(form_data, create):
"""Save the dictionary to the model.
:param form_data: What to save to the model
:param create: Whether a POST or PUT
:return:
"""
default_campaigns = []
if 'is_default' in form_data and form_data['is_default']:
# Get all campaigns where is_default is set.
default_campaigns = CampaignModel.query.filter_by(is_default=1).all()
# Handle toggling of the field is_default.
if create and len(default_campaigns) == 1:
default_campaigns[0].is_default = 0
elif not create and len(default_campaigns) == 1:
if default_campaigns[0].id != form_data['id']:
default_campaigns[0].is_default = 0
try:
if create:
campaign_model = from_json(CampaignSchema(), form_data)
database.session.add(campaign_model.data)
database.session.flush()
else:
campaign_model = CampaignModel.query.get(int(form_data['id']))
# This is a PUT and the Campaign needs to exist.
if campaign_model:
# Make sure the photo_type gets put on the update.
form_data['photo_type'] = campaign_model.photo_type
campaign_model = CampaignSchema().load(form_data,
instance=campaign_model,
partial=True)
else:
raise ModelCampaignImproperFieldError
except MarshmallowValidationError as error:
raise error
except SQLAlchemyError as error:
database.session.rollback()
raise error
return campaign_model
def test_campaigns_default( self ):
"""Retrieve all default or not default Campaigns API ( methods = [ GET ] )."""
with self.app.app_context():
url = '/donation/campaigns/default/1'
total_default_campaigns = 1
campaign_models = create_model_list(
CampaignSchema(), get_campaign_dict( { 'is_default': 1 } ), total_default_campaigns
)
database.session.bulk_save_objects( campaign_models )
total_not_default_campaigns = 2
campaign_models = create_model_list(
CampaignSchema(), get_campaign_dict( { 'is_default': 0 } ), total_not_default_campaigns
)
database.session.bulk_save_objects( campaign_models )
database.session.commit()
response = self.test_client.get( url, headers=self.headers )
self.assertEqual( json.loads( response.data.decode( 'utf-8' ) )[ 'is_default' ], 1 )
def test_campaigns_active( self ):
"""Retrieve all active or inactive Campaigns API ( methods = [ GET ] )."""
with self.app.app_context():
url = '/donation/campaigns/active/1'
total_active_campaigns = 3
campaign_models = create_model_list(
CampaignSchema(), get_campaign_dict( { 'is_active': 1 } ), total_active_campaigns
)
database.session.bulk_save_objects( campaign_models )
total_inactive_campaigns = 2
campaign_models = create_model_list(
CampaignSchema(), get_campaign_dict( { 'is_active': 0 } ), total_inactive_campaigns
)
database.session.bulk_save_objects( campaign_models )
database.session.commit()
response = self.test_client.get( url, headers=self.headers )
self.assertEqual( len( json.loads( response.data.decode( 'utf-8' ) ) ), total_active_campaigns )
def get(self, zero_or_one):
"""Endpoint to retrieve campaigns by filter criteria."""
campaigns = get_campaigns_by_type('is_default', zero_or_one)
if campaigns or campaigns == []:
schema = CampaignSchema(many=True)
result = schema.dump(campaigns).data
if not result: # pylint: disable=no-else-return
# Return the empty list.
return []
elif len(result) == 1:
# If there is one campaign then return the object.
return result[0]
# Handle the case where there are multiple campaigns to return.
if not zero_or_one:
# If asking for non-default campaigns return the list.
return result
# If asking for default campaign and there is more than one: raise the error.
raise CampaignIsDefaultError
return None, status.HTTP_500_INTERNAL_SERVER_ERROR
def test_update_campaign_with_image(
self,
mock_init_storage_function,
mock_save_function,
mock_delete_function
): # pylint: disable=unused-argument, too-many-arguments
"""Update an image on the Campaign ( methods = [ POST ] )."""
with self.app.app_context():
amounts = get_campaign_amount_jsons()[ 0:3 ]
# Get the model that will have some, but not all, fields updated.
campaign_model = from_json( CampaignSchema(), get_campaign_dict() ).data
database.session.add( campaign_model )
amount_models = [ from_json( CampaignAmountsSchema(), amount ).data for amount in amounts ]
database.session.bulk_save_objects( amount_models )
database.session.commit()
form_data = get_update_campaign_dict( { 'id': 1, 'photo_type': 'jpeg' } )
form_data[ 'amounts' ] = json.dumps( amounts[ 0:1 ] )
response = self.get_response( '/donation/campaigns', form_data )
self.assertEqual( response.status_code, status.HTTP_200_OK )
campaign_model_updated = CampaignModel.query.filter_by( id=1 ).one()
# Make sure the fields that are to be updated actually get updated.
self.assertEqual( campaign_model_updated.description, form_data[ 'description' ] )
self.assertEqual( campaign_model_updated.message, form_data[ 'message' ] )
self.assertEqual( campaign_model_updated.photo_type, form_data[ 'photo_type' ] )
self.assertEqual( campaign_model_updated.background, int( form_data[ 'background' ] ) )
# Make sure the fields that were not updated don't change.
self.assertEqual( campaign_model.name, campaign_model_updated.name )
self.assertEqual( campaign_model.date_from_utc, campaign_model_updated.date_from_utc )
self.assertEqual( campaign_model.date_to_utc, campaign_model_updated.date_to_utc )
self.assertEqual( campaign_model.video_name, campaign_model_updated.video_name )
self.assertEqual( campaign_model.video_url, campaign_model_updated.video_url )
self.assertEqual( campaign_model.is_active, campaign_model_updated.is_active )
self.assertEqual( campaign_model.is_default, campaign_model_updated.is_default )
for index, campaign_amount_model in enumerate( CampaignAmountsModel.query.all() ):
self.assertEqual( campaign_amount_model.amount, Decimal( amounts[ index ][ 'amount' ] ) )
self.assertEqual( campaign_amount_model.weight, int( amounts[ index ][ 'weight' ] ) )
self.assertEqual( campaign_amount_model.campaign_id, int( amounts[ index ][ 'campaign_id' ] ) )
def test_get_campaign( self ):
"""Retrieve a Campaign given the ID ( methods = [ GET ] )."""
with self.app.app_context():
url = '/donation/campaigns/2'
total_campaigns = 4
campaign_models = create_model_list(
CampaignSchema(), get_campaign_dict(), total_campaigns
)
database.session.bulk_save_objects( campaign_models )
database.session.commit()
response = self.test_client.get( url, headers=self.headers )
campaign_returned = json.loads( response.data.decode( 'utf-8' ) )
self.assertEqual( campaign_returned[ 'id' ], 2 )