def test_create_transaction(self):
session = DbSessionHolder(TestV1API.REST_TEST_DB).get_session()
create_user(session,
"0000",
"Finn",
"1413434",
233.05)
endpoint = gen_resource_url(API_PREFIX, v1, TRANSACTION_POST_URI)
response = self.client().post(endpoint, data=json.dumps({
"user": "******",
"amount": 52,
"type": TransactionType.FUNDS_DEPOSIT
}))
self.assertEqual("/transaction/1", response.headers["location"])
# The user balance has changed
finn_balance = get_user_balance(session, "0000") # Finn's phone is his ID
self.assertEqual(285.05, finn_balance)
error_response_1 = self.client().post(endpoint, data=json.dumps({
"user": "******",
"amount": 0,
"type": TransactionType.FUNDS_DEPOSIT
}))
self.assertEqual('{"error":"If no money is moved, this is not a money transaction!"}', error_response_1.data.strip())
error_response_2 = self.client().post(endpoint, data=json.dumps({
"user": "******",
"amount": -300,
"type": TransactionType.FUNDS_DEPOSIT
}))
self.assertEqual('{"error":"Not enough money in your wallet!"}', error_response_2.data.strip())
def test_get_user_transactions(self):
session = DbSessionHolder(TestV1API.REST_TEST_DB).get_session()
finn_uri = create_user(session,
"0000",
"Finn",
"1413434",
233.05)
create_transaction(session, amount=10, user_uri=finn_uri, transaction_type=TransactionType.FUNDS_DEPOSIT)
create_transaction(session, amount=3, user_uri=finn_uri, transaction_type=TransactionType.FUNDS_DEPOSIT)
create_transaction(session, amount=-4.05, user_uri=finn_uri, transaction_type=TransactionType.FUNDS_WITHDRAWAL)
endpoint = gen_resource_url(API_PREFIX, v1, USER_GET_TRANSACTIONS_URI.format(user_id="0000"))
response = self.client().get(endpoint)
self.assertItemsEqual(["/transaction/1", "/transaction/2", "/transaction/3"], json.loads(response.data))
endpoint = gen_resource_url(API_PREFIX, v1, USER_GET_EXPANDED_TRANSACTIONS_URI.format(user_id="0000"))
response = self.client().get(endpoint)
expected = [
{"amount": 10.0, "id": 1, "type": "FUNDS_DEPOSIT", "user": "******"},
{"amount": 3.0, "id": 2, "type": "FUNDS_DEPOSIT", "user": "******"},
{"amount": -4.05, "id": 3, "type": "FUNDS_WITHDRAWAL", "user": "******"}
]
parsed_response = json.loads(response.data)
for mov in parsed_response:
del mov["created"]
self.assertItemsEqual(expected, parsed_response)
def test_create_transfer(self):
session = DbSessionHolder(TestV1API.REST_TEST_DB).get_session()
finn_uri = create_user(session,
"0000",
"Finn",
"1413434",
233.05)
jake_uri = create_user(session,
"0001",
"Jake",
"1413434",
60.)
transfer_data = {
"sender": finn_uri,
"receiver": jake_uri,
"amount": 13.05,
"comment": "I want to get ride of small coins!",
"type": TransferType.PUBLIC
}
endpoint = gen_resource_url(API_PREFIX, v1, TRANSFER_POST_URI)
response = self.client().post(endpoint, data=json.dumps(transfer_data))
self.assertEqual("/transfer/1", response.headers["location"])
finn_balance = get_user_balance(session, "0000")
jake_balance = get_user_balance(session, "0001")
self.assertEqual((220.05, 73.0), (finn_balance, jake_balance))
def post(self):
"""
Creates a money transaction.
"""
json_data = request.get_json(force=True)
session = DbSessionHolder().get_session()
try:
# Check that we are not giving the resource a transfer type
if "TRANSFER" in json_data["type"]:
raise ValueError("A single transaction cannot be of 'TRANSFER' type")
# Create the resource
transaction_uri = create_transaction(session,
json_data["user"],
json_data["amount"],
json_data["type"])
response = make_response(jsonify(json_data),
status.HTTP_201_CREATED)
response.headers["location"] = transaction_uri
response.autocorrect_location_header = False
return response
except (KeyError, ValueError, NotEnoughMoneyException), e:
return make_response(jsonify({"error": str(e)}),
status.HTTP_400_BAD_REQUEST)
def setUp(self):
app = Flask(__name__)
app.testing = True
app.config["TESTING"] = True
setup_rest_api(app)
self.client = app.test_client
# Init db
DbSessionHolder('sqlite:///' + TestV1API.REST_TEST_DB).reset()
def test_balance(self):
create_user(DbSessionHolder(TestV1API.REST_TEST_DB).get_session(),
"0000",
"Finn",
"1413434",
233.05)
endpoint = gen_resource_url(API_PREFIX, v1, USER_GET_BALANCE_URI.format(user_id="0000"))
response = self.client().get(endpoint)
expected = {
"balance": 233.05,
"user": "******"
}
self.assertDictEqual(expected, json.loads(response.data))
def post(self):
"""
Creates a money transaction.
"""
json_data = request.get_json(force=True)
session = DbSessionHolder().get_session()
try:
withdrawal_uri = create_transaction(
session,
json_data["sender"],
-int(json_data["amount"]),
TransactionType.TRANSFER_WITHDRAWAL,
commit=False
)
deposit_uri = create_transaction(
session,
json_data["receiver"],
int(json_data["amount"]),
TransactionType.TRANSFER_DEPOSIT,
commit=False
)
transfer_uri = create_transfer(
session,
withdrawal_uri,
deposit_uri,
json_data["comment"],
json_data["type"]
)
response = make_response(jsonify(json_data),
status.HTTP_201_CREATED)
response.headers["location"] = transfer_uri
response.autocorrect_location_header = False
return response
except (KeyError, ValueError, NotEnoughMoneyException), e:
return make_response(jsonify({"error": str(e)}),
status.HTTP_400_BAD_REQUEST)
def get(self, user_id):
"""
Gets the balance of a given user
"""
session = DbSessionHolder().get_session()
try:
balance = get_user_balance(session, user_id)
balance_json = {
"balance": balance,
"user": USER_GET_URI.format(user_id=user_id)
}
response = make_response(jsonify(balance_json),
status.HTTP_201_CREATED)
response.autocorrect_location_header = False
return response
except KeyError, e:
return make_response(jsonify({"error": str(e)}),
status.HTTP_400_BAD_REQUEST)
def get(self, user_id):
"""
Gets the balance of a given user
"""
session = DbSessionHolder().get_session()
args = parser.parse(get_args, request)
try:
transactions = get_user_transactions(session,
user_id,
expand=args["expand"])
response = make_response(jsonify(transactions),
status.HTTP_201_CREATED)
response.autocorrect_location_header = False
return response
except Exception, e:
return make_response(jsonify({"error": str(e)}),
status.HTTP_500_INTERNAL_SERVER_ERROR)
def post(self):
"""
Creates a new user.
"""
json_data = request.get_json(force=True)
session = DbSessionHolder().get_session()
try:
user_uri = create_user(session,
json_data["phone_number"],
json_data["name"],
json_data["pass_hash"])
response = make_response(jsonify(json_data),
status.HTTP_201_CREATED)
response.headers["location"] = user_uri
response.autocorrect_location_header = False
return response
except KeyError, e:
return make_response(jsonify({"error": str(e)}),
status.HTTP_400_BAD_REQUEST)
DB_URL = "mysql+pymysql://root:password@db:3306/miniverse"
app = Flask(__name__) # create the application instance :)
app.config.from_object(__name__) # Load config
# Load default config and override config from an environment variable
app.config.update(
dict(SECRET_KEY='super secret key', USERNAME='******', PASSWORD='******'))
app.config.from_envvar('FLASKR_SETTINGS', silent=True)
#Init the DB Session
connected = False
while not connected:
try:
DbSessionHolder(DB_URL)
connected = True
print "Connected to DB"
except pymysql.err.OperationalError:
sleep(1)
print "*", str(e)
except sqlalchemy.exc.OperationalError, e:
sleep(1)
print str(e)
# Init the REST API
setup_rest_api(app)
if __name__ == "__main__":
app.run(
debug=DEBUG,