def load_persons(count):
print("Downloading")
try:
persons = PersonService.load_persons(count)
except requests.exceptions.ConnectionError:
print("Could not download due to connection error.")
else:
print('Inserting persons into db')
PersonService.insert_persons(persons)
print('Done, downloaded {} new persons'.format(len(persons)))
def test_save(self):
person = Person(1, "Ivan")
validator = Validator()
validator.is_valid = MagicMock(return_value=True)
data_context = DataContext()
data_context.save_person = MagicMock()
person_service = PersonService(validator, data_context)
person_service.save(person)
validator.is_valid.assert_called_with(person)
data_context.save_person.assert_called_once()
def test_n_rows_returned_when_born_beetween_called_with_valid_arg():
n = 4
from_date = datetime.strptime('1964-01-01', '%Y-%m-%d')
to_date = datetime.strptime('1966-01-01', '%Y-%m-%d')
res = PersonService.born_between(from_date, to_date)
res = list(r for r in res)
assert len(res) == n
def get_persons_born(date_from, date_to):
try:
persons = PersonService.born_between(date_from, date_to)
for p in persons:
print("{} {}, born: {}".format(p.name_first, p.name_last, p.dob_date))
except OperationalError:
print('Database is empty please download some persons first')
def most_common_passwords(n):
try:
results = PersonService.most_common('passwords', n)
for r in results:
print("{}, {}".format(r.login_password, r.occur))
except OperationalError:
print('Database is empty please download some persons first')
def list_persons(count):
print("Reading persons")
try:
persons = PersonService.get_persons(count)
for p in persons:
print(p.name_first, p.name_last, p.gender, p.dob_age)
except OperationalError:
print('Database is empty please download some persons first')
class TestPersonService:
def setup_method(self):
self.person_service = PersonService('testdb',
host="mongomock://localhost",
port=27017)
self.db = connect('testdb', host="mongomock://localhost", port=27017)
def teardown_method(self):
self.db.drop_database('testdb')
self.db.close()
def test_create(self):
person = self._create("Fred", "123")
self._create("Bill", "123")
assert 1 == Person.objects.count()
assert Person.objects.first().name == person.name
def test_update(self):
self.test_create()
self.person_service.update("123", "Updated")
assert 1 == Person.objects.count()
assert Person.objects.first().name == "Updated"
def test_delete(self):
self.test_create()
self.person_service.delete("123")
assert 0 == Person.objects.count()
def test_get_all(self):
self._create("Fred", "123")
self._create("Tina", "456")
results = self.person_service.get_all()
assert 2 == len(results)
def test_get(self):
self._create("Fred", "123")
self._create("Tina", "456")
results = self.person_service.get("456")
assert 1 == len(results)
def _create(self, name, ssn):
person = Person(name, ssn)
self.person_service.create(person)
return person
def test_correct_int_returned_when_get_avg_age_called_with_arg_male():
res = PersonService.get_avg_age('male')
assert res == 51
def test_correct_float_returned_when_get_gender_percentage_called_with_arg_male(
):
res = PersonService.get_gender_percentage('male')
assert res == 52.0
def test_n_rows_returned_when_get_persons_with_arg_n_called():
n = 2
res = PersonService.get_persons(n)
res = list(r for r in res)
assert len(res) == n
def test_list_with_len_n_returned_when_load_persons_with_arg_n_called():
n = 2
res = PersonService.load_persons(n)
assert len(res) == n
from flask import Blueprint, jsonify, request
from database_manager import DatabaseManager
from person_service import PersonService
from random_user_api import RandomUserApi
from pony.orm import *
person_api_blueprint = Blueprint('person_api', __name__)
db = DatabaseManager().initialize_database()
person_service = PersonService(db)
@person_api_blueprint.route('/api/persons', methods=['POST'])
def add_new_person():
json = request.get_json()
new_person = person_service.add_person(
dict(first_name=json['first_name'], last_name=json['last_name']))
response = jsonify(new_person.to_dict())
response.status_code = 201
return response
@person_api_blueprint.route('/api/persons/<int:person_id>', methods=['DELETE'])
def remove_person(person_id):
try:
person_service.remove_person(person_id)
return ('', 204)
except ObjectNotFound:
return ('', 404)
@person_api_blueprint.route('/api/persons/<int:person_id>', methods=['GET'])
@app.route('/person/<ssn>', methods=['PUT'])
def put(ssn):
output = person_service.update(ssn, request.json['name'])
return jsonify({"result": output})
@app.route('/person/<ssn>', methods=['DELETE'])
def delete(ssn):
count = person_service.delete(ssn)
return jsonify({"result": {"deleted_count": count}})
@app.route('/person', methods=['POST'])
def post():
person = Person(name=request.json['name'], ssn=request.json['ssn'])
output = person_service.create(person)
return make_response(jsonify({"result": output}), 400 if output.get('message') else 201)
if __name__ == '__main__':
host = "mongodb://localhost"
if os.environ.get('IN_DOCKER_CONTAINER', False):
host = os.environ['DB_PORT_27017_TCP_ADDR']
person_service = PersonService('peopledb', host=host, port=27017)
app.run(debug=True, host='0.0.0.0')
def safest_password():
try:
res = PersonService.get_safest_pswd()
print(res.login_password, res.sum_val)
except OperationalError:
print('Database is empty please download some persons first')
def test_1_correct_row_returned_when_get_safest_pswd_called():
res = PersonService.get_safest_pswd()
assert res.login_password == 'kordell1'
assert res.sum_val == 7
def gender_avg_age(gender):
try:
print("{}: {}".format(gender, PersonService.get_avg_age(gender)))
except OperationalError:
print('Database is empty please download some persons first')
def test_n_rows_returned_when_most_common_called_with_arg_passwords_n():
n = 5
res = PersonService.most_common('passwords', n)
res = list(r for r in res)
assert len(res) == n
import sqlite3
from flask import Flask, request, jsonify
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
app = Flask(__name__)
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///person.db"
db = SQLAlchemy(app)
migrate = Migrate(app, db)
from person_service import PersonService
ps = PersonService()
@app.route("/persons", methods=["GET"])
def list_all_persons():
return jsonify(ps.read_all())
@app.route("/persons", methods=["POST"])
def create_person():
person_data = request.get_json()
if not set(["first_name", "last_name", "email", "age"]) <= set(person_data.keys()):
return "missing_required_fields", 400
return ps.create(person_data), 201
@app.route("/persons/<person_id>", methods=["GET"])
def setup_method(self):
self.person_service = PersonService('testdb',
host="mongomock://localhost",
port=27017)
self.db = connect('testdb', host="mongomock://localhost", port=27017)
def clear_db():
print("Clearing db")
PersonService.drop_persons()
def test_person_model_returned_when_create_from_json_called_with_valid_arg():
n = 1
json = PersonService.load_persons(n)
pf = PersonFactory()
res = pf.create_from_json(json[0])
assert type(res) == Person
print("5. Salir\n")
return int(input("Elija una opción: "))
def menu_modificar(self):
print("\n1. cambiar nombre")
print("2. cambiar apellido")
print("3. cambiar edad")
print("4. retroceder\n")
return int(input("Elija una opción: "))
if __name__ == '__main__':
app = App()
while True:
opcion_person = app.menu_person()
service = PersonService(app.persons_db)
if opcion_person == 1:
service.listar()
if opcion_person == 2:
service.agregar_person()
if opcion_person == 3:
modificar = app.menu_modificar()
if modificar > 0 and modificar < 4:
service.modificar(modificar)
else:
break
if opcion_person == 4:
service.eliminar()
if opcion_person < 1 or opcion_person > 4:
break
