def test_invalid_type_in_response_raises_ValidationError(
        httprettified, swagger_dict, sample_model):
    register_spec(swagger_dict)
    register_get("http://localhost/test_http", body='"NOT_COMPLEX_TYPE"')
    with pytest.raises(ValidationError) as excinfo:
        SwaggerClient.from_url(API_DOCS_URL).api_test.testHTTP().result()
    assert "'NOT_COMPLEX_TYPE' is not of type" in str(excinfo.value)

def test_default_value_in_request(httprettified, swagger_dict):
    swagger_dict['paths']['/test_http']['get']['parameters'][0]['default'] = 'X'
    register_spec(swagger_dict)
    register_get("http://localhost/test_http?")
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    resource.testHTTP().result()
    assert ['X'] == httpretty.last_request().querystring['test_param']

def test_basePath_works(httprettified, swagger_dict):
    swagger_dict["basePath"] = "/append"
    register_spec(swagger_dict)
    register_get("http://localhost/append/test_http?test_param=foo")
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    resource.testHTTP(test_param="foo").result()
    assert ["foo"] == httpretty.last_request().querystring['test_param']

def test_hostname_if_passed_overrides_origin_url(httprettified, swagger_dict):
    register_get("http://foo/test_http?", body='')
    swagger_dict['host'] = 'foo'
    register_spec(swagger_dict)
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    resource.testHTTP(test_param="foo").result()
    assert ["foo"] == httpretty.last_request().querystring['test_param']

def test_invalid_spec_raises_SwaggerValidationError(
        httprettified, swagger_dict):
    swagger_dict['paths']['/test_http']['get']['parameters'][0]['type'] = 'X'
    register_spec(swagger_dict)
    with pytest.raises(SwaggerValidationError) as excinfo:
        SwaggerClient.from_url(API_DOCS_URL)
    assert 'is not valid' in str(excinfo.value)

def test_model_missing_required_property_in_response_raises_ValidationError(
        httprettified, swagger_dict, sample_model):
    register_spec(swagger_dict)
    sample_model.pop("id")
    register_get("http://localhost/test_http", body=simplejson.dumps(sample_model))
    with pytest.raises(ValidationError) as excinfo:
        SwaggerClient.from_url(API_DOCS_URL).api_test.testHTTP().result()
    assert "'id' is a required property" in str(excinfo.value)

def test_correct_route_with_basePath_no_slash(httprettified, swagger_dict):
    register_get(
        "http://localhost/lame/test/test_http?test_param=foo",
        body=u'""')
    swagger_dict["basePath"] = "/lame/test"
    register_spec(swagger_dict)
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    assert resource.testHTTP(test_param="foo").result() is None

def test_additionalProperty_in_model_in_response(
        httprettified, swagger_dict, sample_model):
    register_spec(swagger_dict)
    sample_model["extra"] = 42
    register_get("http://localhost/test_http", body=simplejson.dumps(sample_model))
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    result = resource.testHTTP().result()
    assert result.extra == 42

def test_error_on_wrong_type_inside_complex_type(
        httprettified, swagger_dict, sample_model):
    register_spec(swagger_dict)
    sample_model["id"] = "Not Integer"
    register_get("http://localhost/test_http", body=simplejson.dumps(sample_model))
    with pytest.raises(ValidationError) as excinfo:
        SwaggerClient.from_url(API_DOCS_URL).api_test.testHTTP().result()
    assert "'Not Integer' is not of type" in str(excinfo.value)

def test_error_on_missing_type_in_model(
        httprettified, swagger_dict, sample_model):
    register_spec(swagger_dict)
    sample_model["schools"][0] = {}  # Omit 'name'
    register_get("http://localhost/test_http", body=simplejson.dumps(sample_model))
    with pytest.raises(ValidationError) as excinfo:
        SwaggerClient.from_url(API_DOCS_URL).api_test.testHTTP().result()
    assert "'name' is a required property" in str(excinfo.value)

def test_default_value_not_in_request(httprettified, swagger_dict):
    # Default should be applied on the server side so no need to send it in
    # the request.
    swagger_dict['paths']['/test_http']['get']['parameters'][0]['default'] = 'X'
    register_spec(swagger_dict)
    register_get("http://localhost/test_http?")
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    resource.testHTTP().result()
    assert 'test_param' not in httpretty.last_request().querystring

def test_primitive_types_returned_in_response(httprettified, swagger_dict):
    rtypes = {
        'string': '"test"',
        'integer': 42,
        'number': 3.4,
        'boolean': True
    }
    for rtype, rvalue in rtypes.iteritems():
        register_spec(swagger_dict, {'type': rtype})
        register_test_http(body=json.dumps(rvalue))
        assert_result(rvalue)

def test_array_in_response(httprettified, swagger_dict):
    response_spec = {
        'type': 'array',
        'items': {
            'type': 'string',
        },
    }
    register_spec(swagger_dict, response_spec)
    expected_array = ['inky', 'dinky', 'doo']
    register_test_http(body=json.dumps(expected_array))
    assert_result(expected_array)

def test_invalid_primitive_types_in_response_raises_ValidationError(
        httprettified, swagger_dict):
    rtypes = {
        'string': 42,
        'integer': 3.4,
        'number': 'foo',
        'boolean': '"NOT_BOOL"'
    }
    for rtype, rvalue in rtypes.iteritems():
        register_spec(swagger_dict, {'type': rtype})
        register_test_http(body=json.dumps(rvalue))
        assert_raises_and_matches(ValidationError, 'is not of type')

def test_parameter_in_path_of_request(httprettified, swagger_dict):
    path_param_spec = {
        "in": "path",
        "name": "param_id",
        "type": "string"
    }
    paths_spec = swagger_dict['paths']
    paths_spec['/test_http/{param_id}'] = paths_spec.pop('/test_http')
    paths_spec['/test_http/{param_id}']['get']['parameters'].append(
        path_param_spec)
    register_spec(swagger_dict)
    register_get('http://localhost/test_http/42?test_param=foo')
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    assert resource.testHTTP(test_param="foo", param_id="42").result() is None

def test_parameter_in_path_of_request(httprettified, swagger_dict):
    path_param_spec = {
        'in': 'path',
        'name': 'param_id',
        'required': True,
        'type': 'string',
    }
    paths_spec = swagger_dict['paths']
    paths_spec['/test_http/{param_id}'] = paths_spec.pop('/test_http')
    paths_spec['/test_http/{param_id}']['get']['parameters'].append(
        path_param_spec)
    register_spec(swagger_dict)
    register_get('http://localhost/test_http/42?test_param=foo')
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    assert resource.testHTTP(test_param='foo', param_id='42').result() is None

def test_model_in_response(httprettified, swagger_dict, sample_model):
    register_spec(swagger_dict)
    register_get("http://localhost/test_http", body=json.dumps(sample_model))
    client = SwaggerClient.from_url(API_DOCS_URL)
    result = client.api_test.testHTTP().result()
    User = client.get_model('User')
    School = client.get_model('School')
    assert isinstance(result, User)
    for school in result.schools:
        assert isinstance(school, School)
    assert User(
        id=42,
        schools=[
            School(name="School1"),
            School(name="School2")
        ]) == result

def test_model_in_body_of_request(httprettified, swagger_dict, sample_model):
    param_spec = {
        "in": "body",
        "name": "body",
        "schema": {
            "$ref": "#/definitions/User"
        }
    }
    swagger_dict["paths"]["/test_http"]['post']["parameters"] = [param_spec]
    register_spec(swagger_dict)
    httpretty.register_uri(httpretty.POST, "http://localhost/test_http")
    client = SwaggerClient.from_url(API_DOCS_URL)
    resource = client.api_test
    User = client.get_model('User')
    School = client.get_model('School')
    user = User(id=42, schools=[School(name='s1')])
    resource.testHTTPPost(body=user).result()
    body = simplejson.loads(httpretty.last_request().body.decode('utf-8'))
    assert {'schools': [{'name': 's1'}], 'id': 42} == body

def test_array_with_collection_format_in_path_of_request(
        httprettified, swagger_dict):
    path_param_spec = {
        'in': 'path',
        'name': 'param_ids',
        'type': 'array',
        'items': {
            'type': 'integer'
        },
        'collectionFormat': 'csv',
    }
    swagger_dict['paths']['/test_http/{param_ids}'] = \
        swagger_dict['paths'].pop('/test_http')
    swagger_dict['paths']['/test_http/{param_ids}']['get']['parameters'] = \
        [path_param_spec]
    register_spec(swagger_dict)
    register_get('http://localhost/test_http/40,41,42')
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    assert resource.testHTTP(param_ids=[40, 41, 42]).result() is None

def test_form_params_in_request(httprettified, swagger_dict):
    param1_spec = {
        "in": "formData",
        "name": "param_id",
        "type": "integer"
    }
    param2_spec = {
        "in": "formData",
        "name": "param_name",
        "type": "string"
    }
    path_spec = swagger_dict['paths']['/test_http']
    path_spec['post'] = path_spec.pop('get')
    path_spec['post']['parameters'] = [param1_spec, param2_spec]
    register_spec(swagger_dict)
    httpretty.register_uri(httpretty.POST, "http://localhost/test_http?")
    resource = SwaggerClient.from_url(API_DOCS_URL).api_test
    resource.testHTTP(param_id=42, param_name='foo').result()
    content_type = httpretty.last_request().headers['content-type']
    assert 'application/x-www-form-urlencoded' == content_type
    body = urlparse.parse_qs(httpretty.last_request().body)
    assert {b'param_name': [b'foo'], b'param_id': [b'42']} == body