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 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__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__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__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 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__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__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 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_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__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__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 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 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__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__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__loan_purpose_default(self):
     serializer = ParamsSerializer(data=self.data)
     self.assertTrue(serializer.is_valid())
     self.assertEqual(serializer.data.get('loan_purpose'), ParamsSerializer.LOAN_PURPOSE)

 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)