def create_actor(payload):
try:
# params from request
body = request.get_json()
name = body.get('name')
age = body.get('age')
gender = body.get('gender')
movie_id = body.get('movie_id')
#
actor = Actor(name, age, gender, movie_id)
print(actor.format())
actor.insert()
return jsonify({"success": True, "actor": actor.format()})
except BaseException:
abort(422)
def add_actor(token):
data = request.get_json()
actor_name = data.get('name', None)
actor_age = data.get('age', None)
actor_gender = data.get('gender', None)
if not actor_name or not actor_age or not actor_gender:
abort(400)
existing_actor = Actor.query.filter(
Actor.name == actor_name,
Actor.age == actor_age,
Actor.gender == actor_gender).one_or_none()
if existing_actor:
abort(422)
try:
actor_data = Actor(name=actor_name, age=actor_age, gender=actor_gender)
actor_data.insert()
return jsonify({
'success': True,
'actor': actor_data.format()
}), 201
except Exception as error:
print(error)
abort(422)
def add_actor(payload):
# Extract relevant details from request.
req_data = request.get_json()
name = req_data['name']
age = req_data['age']
gender = req_data['gender']
# Check if age is integer
if type(age) is int:
pass
else:
abort(422)
# Create new
newActor = Actor(
name=name,
age=age,
gender=gender
)
# Save
try:
newActor.insert()
except:
abort(500)
finally:
# Return
actor = newActor.format()
return jsonify({
'success': True,
'actors': actor
})
def new_actor(jwt):
try:
data = request.get_json('actor')
actor = Actor(name=data['name'],
age=data['age'],
gender=data['gender'])
actor.insert()
except Exception:
abort(400)
return jsonify({'success': True, 'actors': [actor.format()]})
def post_actor(payload):
data = request.get_json()
try:
actor = Actor(name=data['name'],
gender=data['gender'],
age=data['age'])
actor.insert()
return jsonify({'success': True, 'actor': actor.format()}), 200
except:
abort(422)
def add_actor(payload):
try:
body = request.get_json()
name_requested = body.get("name", None)
age_requested = body.get("age", None)
gender_requested = body.get("gender", None)
actor = Actor(name=name_requested,
age=age_requested,
gender=gender_requested)
actor.insert()
return jsonify({"success": True, "actor_created": actor.format()})
except:
abort(422)
def create_actor(jwt):
try:
data = request.get_json()
actor = Actor(name=data.get('name'),
age=data.get('age'),
gender=data.get('gender'))
actor.insert()
return jsonify({'success': True, 'actors': actor.format()}), 200
except BaseException:
abort(422)
def add_actor(jwt):
body = request.get_json()
req_name = body.get('name')
req_age = body.get('age')
req_gender = body.get('gender')
if not req_name:
abort(422)
actor = Actor(name=req_name, age=req_age, gender=req_gender)
actor.insert()
return jsonify({
'success': True,
'actors': actor.format()
})
def create_actors(*args, **kwargs):
try:
body = request.get_json()
new_name = body.get('name')
new_age = body.get('age')
new_gender = body.get('gender')
actor = Actor(name=new_name, age=new_age, gender=new_gender)
actor.insert()
return jsonify({
'success': True,
"message": "Actor Successfully Added!",
"actor": actor.format()
})
except AttributeError:
abort(422)
def add_actor(payload):
body = request.get_json()
if body is None:
abort(400)
name = body.get('name') or None
age = body.get('age') or None
gender = body.get('gender') or None
if ((name is None) or (age is None) or (gender is None)):
abort(400)
actor = Actor(name=name, age=age, gender=gender)
try:
actor.insert()
except Exception as e:
abort(422)
return jsonify({
'success': True,
'actor': actor.format()
}), 200
def add_actor():
body = request.get_json()
name = body.get('name')
age = body.get('age')
gender = body.get('gender')
try:
actor = Actor(name=name, age=age, gender=gender)
actor.insert()
return jsonify({
"success": True,
"created": actor.id,
"actors": [actor.format()]
})
except Exception as e:
error = True
print(sys.exc_info())
print(e)
abort(422)
def addActor():
body = request.get_json()
try:
name = body.get('name', None)
age = body.get('age', None)
# Check of any missing parameter.
if name is None or age is None:
abort(400)
actor = Actor(name=name, age=age)
actor.insert()
return jsonify({
'success': True,
'actor_added': actor.format()
})
except Exception as e:
abort(422)
def create_actor(payload):
body = request.get_json()
name = body.get('name', None)
age = body.get('age', None)
gender = body.get('gender', None)
try:
actor = Actor(name=name, age=age, gender=gender)
actor.insert()
selection = Actor.query.order_by(Actor.id).all()
actors = [actor.format() for actor in selection]
return jsonify({
'success': True,
'created': actor.id,
'actors': actors,
'totalActors': len(Actor.query.all())
})
except Exception:
abort(422)
def add_new_actor(token):
# handler request data
data = request.get_json()
# if request body is empty return 400 error
if data is None:
abort(400)
# try get data from request body
try:
name = data["name"]
age = data["age"]
gender = data["gender"]
# if data handling is unsuccessful return 400 error
except KeyError:
abort(400)
# validate request data, if TRUE:
if validate(name, age, gender):
# build actor data
new_actor = Actor(name=name, age=age, gender=gender.lower())
# check for: if actor exits!
actor = Actor.query.filter_by(name=name, age=age).first()
# if actor found, return json response with required message
if actor:
return jsonify({
"mesage": "This actor is already available",
"success": False
}), 200
# else: insert new actor to database
try:
new_actor.insert()
# if this operation was unsuccessful: return 422 error
except:
abort(422)
# build response data with actor data
response = {"success": True, "actor": new_actor.format()}
# return response
return jsonify(response), 200
return abort(400)
def post_actor(jwt):
# Declare and empty data dictionary to hold all retrieved variables
data = request.get_json()
# set actor variable equal to corresponding model class,
# ready for adding to the session
actor = data.get('actor')
actor = Actor(name=data.get('name'),
age=data.get('age'),
gender=data.get('gender'))
try:
actor.insert()
except Exception:
abort(400)
actors = Actor.query.all()
try:
actors = [actor.format() for actor in actors]
return jsonify({'success': True, 'actors': actors}), 200
except Exception:
abort(500)
class CastingTestCase(unittest.TestCase):
"""This class represents the casting test case"""
def setUp(self):
"""Define test variables and initialize the app"""
self.app = create_app()
self.client = self.app.test_client
self.executive_producer_jwt = os.environ.get('EXECUTIVE_PRODUCER')
self.casting_manager_jwt = os.environ.get('CASTING_MANAGER')
self.casting_assistant_jwt = os.environ.get('CASTING_ASSISTANT')
self.executive_producer = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self.executive_producer_jwt)
}
self.casting_manager = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self.casting_manager_jwt)
}
self.casting_assistant = {
"Content-Type": "application/json",
"Authorization": "Bearer {}".format(self.casting_assistant_jwt)
}
self.new_actor = Actor(name="Test_Actor", age=45, gender='Male')
self.new_movie = Movie(title='Test_Movie', release_date='2016-12-06')
# binds the app to the current context
with self.app.app_context():
self.db = SQLAlchemy()
self.db.init_app(self.app)
self.db.create_all
def tearDown(self):
"""Executed after reach test"""
pass
def test_get_actors(self):
res = self.client().get('/actors', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actors'])
def test_post_actors(self):
res = self.client().post('/actors',
json=self.new_actor.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['actors'])
def test_delete_actors(self):
actor = self.new_actor
actor.insert()
res = self.client().delete('/actors/{}'.format(actor.id),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['deleted'])
def test_patch_actors(self):
actor = self.new_actor
actor.insert()
patched_actor = self.new_actor
patched_actor.age = 34
res = self.client().patch('/actors/{}'.format(actor.id),
json=patched_actor.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['actors'])
def test_get_movies(self):
res = self.client().get('/movies', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['movies'])
def test_post_movies(self):
res = self.client().post('/movies',
json=self.new_movie.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['movies'])
def test_delete_movies(self):
movie = self.new_movie
movie.insert()
res = self.client().delete('/movies/{}'.format(movie.id),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['deleted'])
def test_patch_movies(self):
movie = self.new_movie
movie.insert()
patched_movie = movie
patched_movie.title = 'New Title'
res = self.client().patch('/movies/{}'.format(movie.id),
json=patched_movie.format(),
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['movies'])
# Errors
def test_401_get_actors(self):
res = self.client().get('/actors')
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
def test_401_get_movies(self):
res = self.client().get('/movies')
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
def test_400_post_actors(self):
res = self.client().post('/actors', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 400)
def test_404_delete_actors(self):
res = self.client().delete('/actors/234255',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
def test_404_patch_actors(self):
res = self.client().patch('/actors/5365436',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
def test_400_post_movies(self):
res = self.client().post('/movies', headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 400)
def test_404_delete_movies(self):
res = self.client().delete('/movies/234255',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
def test_404_patch_movies(self):
res = self.client().patch('/movies/5365436',
headers=self.executive_producer)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 404)
# Role Based Authentication
def test_get_actors_casting_assistant(self):
res = self.client().get('/actors', headers=self.casting_assistant)
data = json.loads(res.data)
self.assertEqual(res.status_code, 200)
self.assertEqual(data['success'], True)
self.assertTrue(data['actors'])
def test_post_actors_casting_assistant(self):
res = self.client().post('/actors',
json=self.new_actor.format(),
headers=self.casting_assistant)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
def test_post_actors_casting_manager(self):
res = self.client().post('/actors',
json=self.new_actor.format(),
headers=self.casting_manager)
data = json.loads(res.data)
self.assertEqual(data['success'], True)
self.assertEqual(res.status_code, 200)
self.assertTrue(data['actors'])
def test_401_delete_movies_casting_manager(self):
movie = self.new_movie
movie.insert()
res = self.client().delete('/movies/{}'.format(movie.id),
headers=self.casting_manager)
data = json.loads(res.data)
self.assertEqual(data['success'], False)
self.assertEqual(res.status_code, 401)
