def test_is_valid__lock_default(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data.get("lock"),
ParamsSerializer.LOCK)
self.assertEqual(serializer.validated_data.get("min_lock"), 46)
self.assertEqual(serializer.validated_data.get("max_lock"), 60)
def rate_checker(request):
"""
Return available rates in percentage and number of institutions
with the corresponding rate
(i.e. "4.75": 2 means there are 2 institutions with the rate of 4.75%)
"""
if request.method == 'GET':
# Clean the parameters, make sure no leading or trailing spaces,
# transform them to upper cases
fixed_data = {
k: v.strip().upper()
for k, v in request.query_params.items()
}
fixed_data = set_lock_max_min(fixed_data)
serializer = ParamsSerializer(data=fixed_data)
if serializer.is_valid():
rate_results = get_rates(serializer.validated_data)
rate_results['request'] = serializer.validated_data
return Response(rate_results)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_is_valid__maxfico_smaller(self):
self.data['maxfico'] = 600
self.data['minfico'] = 700
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('maxfico'), 700)
self.assertEqual(serializer.data.get('minfico'), 600)
def test_is_valid__ltv__without_ltv(self):
self.data['price'] = 200000
self.data['loan_amount'] = 180000
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('min_ltv'), 90)
self.assertTrue(serializer.data.get('min_ltv'), serializer.data.get('max_ltv'))
def test_is_valid__lock_non_default(self):
self.data['lock'] = 30
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('lock'), 30)
self.assertEqual(serializer.data.get('min_lock'), 0)
self.assertEqual(serializer.data.get('max_lock'), 30)
def test_is_valid__ficos_negative(self):
self.data['maxfico'] = -100
self.data['minfico'] = -200
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('maxfico'), 200)
self.assertEqual(serializer.data.get('minfico'), 100)
def test_is_valid__ficos_negative(self):
self.data['maxfico'] = -100
self.data['minfico'] = -200
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('maxfico'), 200)
self.assertEqual(serializer.data.get('minfico'), 100)
def test_is_valid__lock_non_default(self):
self.data['lock'] = 30
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('lock'), 30)
self.assertEqual(serializer.data.get('min_lock'), 0)
self.assertEqual(serializer.data.get('max_lock'), 30)
def test_is_valid__loan_purpose_default(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(
serializer.validated_data.get("loan_purpose"),
ParamsSerializer.LOAN_PURPOSE,
)
def test_is_valid__ficos_negative(self):
self.data["maxfico"] = -100
self.data["minfico"] = -200
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data.get("maxfico"), 200)
self.assertEqual(serializer.validated_data.get("minfico"), 100)
def test_is_valid__maxfico_smaller(self):
self.data["maxfico"] = 600
self.data["minfico"] = 700
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data.get("maxfico"), 700)
self.assertEqual(serializer.validated_data.get("minfico"), 600)
def test_is_valid__loan_type_invalid(self):
self.data['loan_type'] = 'A'
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get('loan_type'),
[u'Select a valid choice. A is not one of the available choices.'])
def test_is_valid__maxfico_smaller(self):
self.data['maxfico'] = 600
self.data['minfico'] = 700
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('maxfico'), 700)
self.assertEqual(serializer.data.get('minfico'), 600)
def test_is_valid__state_invalid(self):
self.data['state'] = 123
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('state'), [
u'Select a valid choice. 123 is not one of the available choices.'
])
def rate_checker(request):
"""
Return available rates in percentage and number of institutions
with the corresponding rate
(i.e. "4.75": 2 means there are 2 institutions with the rate of 4.75%)
"""
if request.method == "GET":
# Clean the parameters, make sure no leading or trailing spaces,
# transform them to upper cases
fixed_data = {
k: v.strip().upper()
for k, v in request.query_params.items()
} # noqa
fixed_data = set_lock_max_min(fixed_data)
serializer = ParamsSerializer(data=fixed_data)
if serializer.is_valid():
rate_results = get_rates(serializer.validated_data)
rate_results["request"] = serializer.validated_data
return Response(rate_results)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_is_valid__property_type_default(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(
serializer.validated_data.get("property_type"),
ParamsSerializer.PROPERTY_TYPE,
)
def test_is_valid__rate_structure_arm_no_arm_type(self):
self.data["rate_structure"] = "ARM"
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("non_field_errors"),
["arm_type is required if rate_structure is ARM."],
)
def test_is_valid__loan_amount_empty(self):
self.data['loan_amount'] = ''
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get('loan_amount'),
[u'A valid number is required.']
)
def validate_scenario(self, scenario, expected_result):
serializer = ParamsSerializer(data=scenario)
serializer.is_valid(raise_exception=True)
rates = get_rates(serializer.validated_data, data_load_testing=True)
computed_rates = rates.get("data")
return self.compare_result(computed_rates, expected_result)
def test_is_valid__ltv__without_ltv(self):
self.data['price'] = 200000
self.data['loan_amount'] = 180000
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('min_ltv'), 90)
self.assertTrue(serializer.data.get('min_ltv'),
serializer.data.get('max_ltv'))
def validate_scenario(self, scenario, expected_result):
serializer = ParamsSerializer(data=scenario)
serializer.is_valid(raise_exception=True)
rates = get_rates(serializer.validated_data, data_load_testing=True)
computed_rates = rates.get('data')
return self.compare_result(computed_rates, expected_result)
def test_is_valid__property_type_invalid(self):
self.data['property_type'] = 'A'
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get('property_type'),
[u'"A" is not a valid choice.']
)
def test_is_valid__loan_term_not_choice(self):
self.data["loan_term"] = 20
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("loan_term"),
["loan_term needs to be 15 or 30."],
)
def test_is_valid__state_invalid(self):
self.data['state'] = 123
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get('state'),
[u'"123" is not a valid choice.']
)
def test_is_valid__loan_amount_none(self):
self.data['loan_amount'] = None
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get('loan_amount'),
[u'This field may not be null.']
)
def test_is_valid__property_type_invalid(self):
self.data["property_type"] = "A"
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("property_type"),
['"A" is not a valid choice.'],
)
def test_is_valid__loan_amount_none(self):
self.data["loan_amount"] = None
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("loan_amount"),
["This field may not be null."],
)
def test_is_valid__loan_purpose_invalid(self):
self.data["loan_purpose"] = "A"
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("loan_purpose"),
['"A" is not a valid choice.'],
)
def test_is_valid__loan_purpose_invalid(self):
self.data['loan_purpose'] = 'A'
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get('loan_purpose'),
[u'"A" is not a valid choice.']
)
def test_is_valid__loan_amount_empty(self):
self.data["loan_amount"] = ""
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(
serializer.errors.get("loan_amount"),
["A valid number is required."],
)
def test_is_valid__lock_non_default(self):
self.data["lock"] = 30
self.data["min_lock"] = 0
self.data["max_lock"] = 30
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data.get("lock"), 30)
self.assertEqual(serializer.validated_data.get("min_lock"), 0)
self.assertEqual(serializer.validated_data.get("max_lock"), 30)
def test_is_valid_no_price_or_ltv(self):
data = dict(self.data)
data.pop('price', None)
data.pop('ltv', None)
serializer = ParamsSerializer(data=data)
self.assertFalse(serializer.is_valid())
self.assertIn(
'one of price or ltv is required',
serializer.errors['non_field_errors']
)
def test_is_valid_no_price_or_ltv(self):
data = dict(self.data)
data.pop("price", None)
data.pop("ltv", None)
serializer = ParamsSerializer(data=data)
self.assertFalse(serializer.is_valid())
self.assertIn(
"one of price or ltv is required",
serializer.errors["non_field_errors"],
)
def test_is_valid__ltv__without_ltv(self):
self.data["price"] = 200000
self.data["loan_amount"] = 180000
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data.get("min_ltv"), 90)
self.assertTrue(
serializer.validated_data.get("min_ltv"),
serializer.validated_data.get("max_ltv"),
)
def test_is_valid__no_args(self):
serializer = ParamsSerializer(data={})
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors), 7)
self.assertEqual(serializer.errors.get('loan_amount'), [u'This field is required.'])
self.assertEqual(serializer.errors.get('state'), [u'This field is required.'])
self.assertEqual(serializer.errors.get('loan_type'), [u'This field is required.'])
self.assertEqual(serializer.errors.get('minfico'), [u'This field is required.'])
self.assertEqual(serializer.errors.get('maxfico'), [u'This field is required.'])
self.assertEqual(serializer.errors.get('rate_structure'), [u'This field is required.'])
self.assertEqual(serializer.errors.get('loan_term'), [u'This field is required.'])
def test_is_valid__valid_args(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('price'), Decimal('240000'))
self.assertEqual(serializer.data.get('loan_amount'), Decimal('200000'))
self.assertEqual(serializer.data.get('state'), 'GA')
self.assertEqual(serializer.data.get('loan_type'), 'JUMBO')
self.assertEqual(serializer.data.get('minfico'), 700)
self.assertEqual(serializer.data.get('maxfico'), 800)
self.assertEqual(serializer.data.get('rate_structure'), 'FIXED')
self.assertEqual(serializer.data.get('loan_term'), 30)
def test_is_valid__valid_args(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('price'), Decimal('240000'))
self.assertEqual(serializer.data.get('loan_amount'), Decimal('200000'))
self.assertEqual(serializer.data.get('state'), 'GA')
self.assertEqual(serializer.data.get('loan_type'), 'JUMBO')
self.assertEqual(serializer.data.get('minfico'), 700)
self.assertEqual(serializer.data.get('maxfico'), 800)
self.assertEqual(serializer.data.get('rate_structure'), 'FIXED')
self.assertEqual(serializer.data.get('loan_term'), 30)
def test_is_valid__valid_args(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.validated_data.get("price"),
Decimal("240000"))
self.assertEqual(serializer.validated_data.get("loan_amount"),
Decimal("200000"))
self.assertEqual(serializer.validated_data.get("state"), "GA")
self.assertEqual(serializer.validated_data.get("loan_type"), "JUMBO")
self.assertEqual(serializer.validated_data.get("minfico"), 700)
self.assertEqual(serializer.validated_data.get("maxfico"), 800)
self.assertEqual(serializer.validated_data.get("rate_structure"),
"FIXED")
self.assertEqual(serializer.validated_data.get("loan_term"), 30)
def rate_checker_fees(request):
""" Return available rates in percentage and number of institutions with the corresponding
rate along with fees data """
if request.method == 'GET':
# Clean the parameters, make sure no leading or trailing spaces, transform them to upper cases
fixed_data = dict(map(lambda (k, v): (k, v.strip().upper()), request.QUERY_PARAMS.iteritems()))
serializer = ParamsSerializer(data=fixed_data)
if serializer.is_valid():
rate_results = get_rates(serializer.data, return_fees=True)
rate_results['request'] = serializer.data
return Response(rate_results)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def rate_checker(request):
""" Return available rates in percentage and number of institutions with the corresponding rate
(i.e. "4.75": 2 means there are 2 institutions with the rate of 4.75%)"""
if request.method == 'GET':
# Clean the parameters, make sure no leading or trailing spaces, transform them to upper cases
fixed_data = dict(map(lambda (k, v): (k, v.strip().upper()), request.QUERY_PARAMS.iteritems()))
serializer = ParamsSerializer(data=fixed_data)
if serializer.is_valid():
rate_results = get_rates(serializer.data)
rate_results['request'] = serializer.data
return Response(rate_results)
else:
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def compare_scenarios_output(self, precalculated_results):
""" Run scenarios thru API, compare results to <precalculated_results>."""
passed = True
failed = []
for scenario_no in self.test_scenarios:
# since these scenarios use loan_type=AGENCY
if scenario_no in ['16', '42']:
continue
# rcparams = RateCheckerParameters()
# rcparams.set_from_query_params(self.test_scenarios[scenario_no])
serializer = ParamsSerializer(
data=self.test_scenarios[scenario_no])
api_result = get_rates(serializer.data, data_load_testing=True)
expected_rate = "%s" % precalculated_results[scenario_no][0]
expected_points = precalculated_results[scenario_no][1]
if len(api_result['data']) > 1 or\
expected_rate not in api_result['data'] or\
expected_points != api_result['data'][expected_rate]:
if expected_rate is not None and api_result['data']:
passed = False
failed.append(scenario_no)
if not passed:
failed.sort(key=int)
self.messages.append("The following scenarios don't match: %s " %
failed)
def compare_scenarios_output(self, precalculated_results):
""" Run scenarios thru API, compare results to <precalculated_results>."""
passed = True
failed = {}
for scenario_no in self.test_scenarios:
# since these scenarios use loan_type=AGENCY
if scenario_no in ['16', '42']:
continue
serializer = ParamsSerializer(
data=self.test_scenarios[scenario_no])
api_result = get_rates(serializer.data, data_load_testing=True)
expected_rate = "%s" % precalculated_results[scenario_no][0]
expected_points = precalculated_results[scenario_no][1]
if len(api_result['data']) > 1 or\
expected_rate not in api_result['data'] or\
expected_points != api_result['data'][expected_rate]:
if expected_rate is not None and api_result['data']:
passed = False
failed_str = ' scenario_no: ' + str(scenario_no) + \
' Expected: ' + str(precalculated_results[scenario_no]) + \
' Actual: ' + str(api_result['data']) + "<br>"
failed[int(scenario_no)] = failed_str
if not passed:
sorted_failed = []
for i in sorted(failed):
sorted_failed.append(failed[i])
self.messages.append(
"The following scenarios don't match: <br>%s" % sorted_failed)
def test_is_valid__no_args(self):
serializer = ParamsSerializer(data={})
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors), 8)
self.assertEqual(serializer.errors.get('price'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('loan_amount'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('state'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('loan_type'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('minfico'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('maxfico'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('rate_structure'),
[u'This field is required.'])
self.assertEqual(serializer.errors.get('loan_term'),
[u'This field is required.'])
def test_is_valid__no_args(self):
serializer = ParamsSerializer(data={})
self.assertFalse(serializer.is_valid())
self.assertEqual(len(serializer.errors), 7)
self.assertEqual(serializer.errors.get("loan_amount"),
["This field is required."])
self.assertEqual(serializer.errors.get("state"),
["This field is required."])
self.assertEqual(serializer.errors.get("loan_type"),
["This field is required."])
self.assertEqual(serializer.errors.get("minfico"),
["This field is required."])
self.assertEqual(serializer.errors.get("maxfico"),
["This field is required."])
self.assertEqual(
serializer.errors.get("rate_structure"),
["This field is required."],
)
self.assertEqual(serializer.errors.get("loan_term"),
["This field is required."])
def rate_checker_fees(request):
"""
Return available rates in percentage and number of institutions
with the corresponding rate along with fees data
"""
if request.method == 'GET':
# Clean the parameters, make sure no leading or trailing spaces,
# transform them to upper cases
fixed_data = dict(
map(lambda (k, v): (k, v.strip().upper()),
request.query_params.iteritems()))
serializer = ParamsSerializer(data=fixed_data)
if serializer.is_valid():
rate_results = get_rates(serializer.validated_data,
return_fees=True)
rate_results['request'] = serializer.validated_data
return Response(rate_results)
else:
return Response(serializer.errors,
status=status.HTTP_400_BAD_REQUEST)
def test_is_valid__property_type_non_default(self):
self.data['property_type'] = ParamsSerializer.PROPERTY_TYPE_COOP
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('property_type'), ParamsSerializer.PROPERTY_TYPE_COOP)
def test_is_valid__rate_structure_arm_no_arm_type(self):
self.data['rate_structure'] = 'ARM'
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('non_field_errors'),
[u'arm_type is required if rate_structure is ARM.'])
def test_is_valid__loan_purpose_non_default(self):
self.data['loan_purpose'] = Product.REFI
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('loan_purpose'), Product.REFI)
def test_is_valid__points_non_default(self):
self.data['points'] = 4
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('points'), 4)
def test_is_valid__io_invalid(self):
self.data['io'] = 4
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('io'), [u'io needs to be 0 or 1.'])
def test_is_valid__io_non_default(self):
self.data['io'] = 1
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('io'), 1)
def test_is_valid__price_negative(self):
self.data['price'] = -10000
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('price'), Decimal('10000'))
def test_is_valid__loan_amount_negative(self):
self.data['loan_amount'] = -10000
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('loan_amount'), Decimal('10000'))
def test_is_valid__property_type_invalid(self):
self.data['property_type'] = 'A'
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('property_type'),
[u'Select a valid choice. A is not one of the available choices.'])
def test_is_valid__lock_default(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('lock'), ParamsSerializer.LOCK)
self.assertEqual(serializer.data.get('min_lock'), 46)
self.assertEqual(serializer.data.get('max_lock'), 60)
def test_is_valid__loan_term_not_choice(self):
self.data['loan_term'] = 20
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('loan_term'), [u'loan_term needs to be 15 or 30.'])
def test_is_valid__invalid_lock(self):
self.data['lock'] = 20
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('lock'), [u'lock needs to be 30, 45, or 60.'])
def test_is_valid__loan_term_negative(self):
self.data['loan_term'] = -30
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('loan_term'), 30)
def test_is_valid__state_invalid(self):
self.data['state'] = 123
serializer = ParamsSerializer(data=self.data)
self.assertFalse(serializer.is_valid())
self.assertEqual(serializer.errors.get('state'),
[u'Select a valid choice. 123 is not one of the available choices.'])
def test_is_valid__loan_purpose_default(self):
serializer = ParamsSerializer(data=self.data)
self.assertTrue(serializer.is_valid())
self.assertEqual(serializer.data.get('loan_purpose'), ParamsSerializer.LOAN_PURPOSE)
