# coding: utf-8

from coreapi import negotiate_decoder, negotiate_encoder

from coreapi.codecs import CoreJSONCodec, HTMLCodec

from coreapi.codecs.corejson import _document_to_primative, _primative_to_document

from coreapi.document import Document, Link, Error, required

from coreapi.exceptions import ParseError, NotAcceptable

import pytest

@pytest.fixture

def json_codec():

return CoreJSONCodec()

@pytest.fixture

def html_codec():

return HTMLCodec()

@pytest.fixture

def doc():

return Document(

url='http://example.org/',

title='Example',

content={

'integer': 123,

'dict': {'key': 'value'},

'list': [1, 2, 3],

'link': Link(url='http://example.org/'),

'nested': {'child': Link(url='http://example.org/123')},

'_type': 'needs escaping'

})

# Documents have a mapping to python primatives in JSON style.

def test_document_to_primative(doc):

data = _document_to_primative(doc)

assert data == {

'_type': 'document',

'_meta': {

'url': 'http://example.org/',

'title': 'Example'

},

'integer': 123,

'dict': {'key': 'value'},

'list': [1, 2, 3],

'link': {'_type': 'link'},

'nested': {'child': {'_type': 'link', 'url': '/123'}},

'__type': 'needs escaping'

}

def test_primative_to_document(doc):

data = {

'_type': 'document',

'_meta': {

'url': 'http://example.org/',

'title': 'Example'

},

'integer': 123,

'dict': {'key': 'value'},

'list': [1, 2, 3],

'link': {'_type': 'link', 'url': 'http://example.org/'},

'nested': {'child': {'_type': 'link', 'url': 'http://example.org/123'}},

'__type': 'needs escaping'

}

assert _primative_to_document(data) == doc

def test_error_to_primative():

error = Error(['failed'])

data = {

'_type': 'error',

'messages': ['failed']

}

assert _document_to_primative(error) == data

def test_primative_to_error():

error = Error(['failed'])

data = {

'_type': 'error',

'messages': ['failed']

}

assert _primative_to_document(data) == error

# Codecs can load a document successfully.

def test_minimal_document(json_codec):

"""

Ensure we can load the smallest possible valid JSON encoding.

"""

doc = json_codec.load(b'{"_type":"document"}')

assert isinstance(doc, Document)

assert doc.url == ''

assert doc.title == ''

assert doc == {}

def test_minimal_error(json_codec):

"""

Ensure we can load a minimal error message encoding.

"""

error = json_codec.load(b'{"_type":"error","messages":["failed"]}')

assert isinstance(error, Error)

assert error == ['failed']

# Parse errors should be raised for invalid encodings.

def test_malformed_json(json_codec):

"""

Invalid JSON should raise a ParseError.

"""

with pytest.raises(ParseError):

json_codec.load(b'_')

def test_not_a_document(json_codec):

"""

Valid JSON that does not return a document as the top level element

should raise a ParseError.

"""

with pytest.raises(ParseError):

json_codec.load(b'{}')

# Encodings may have a verbose and a compact style.

def test_compact_style(json_codec):

doc = Document(content={'a': 123, 'b': 456})

bytes = json_codec.dump(doc)

assert bytes == b'{"_type":"document","a":123,"b":456}'

def test_verbose_style(json_codec):

doc = Document(content={'a': 123, 'b': 456})

bytes = json_codec.dump(doc, indent=True)

assert bytes == b"""{

"_type": "document",

"a": 123,

"b": 456

}"""

# Links should use compact format for optional fields, verbose for required.

def test_link_encodings(json_codec):

doc = Document(content={

'link': Link(

action='post',

inplace=True,

fields=['optional', required('required')]

)

})

bytes = json_codec.dump(doc, indent=True)

assert bytes == b"""{

"_type": "document",

"link": {

"_type": "link",

"action": "post",

"inplace": true,

"fields": [

"optional",

{

"name": "required",

"required": true

}

]

}

}"""

# Tests for graceful omissions.

def test_invalid_document_meta_ignored(json_codec):

doc = json_codec.load(b'{"_type": "document", "_meta": 1, "a": 1}')

assert doc == Document(content={"a": 1})

def test_invalid_document_url_ignored(json_codec):

doc = json_codec.load(b'{"_type": "document", "_meta": {"url": 1}, "a": 1}')

assert doc == Document(content={"a": 1})

def test_invalid_document_title_ignored(json_codec):

doc = json_codec.load(b'{"_type": "document", "_meta": {"title": 1}, "a": 1}')

assert doc == Document(content={"a": 1})

def test_invalid_link_url_ignored(json_codec):

doc = json_codec.load(b'{"_type": "document", "link": {"_type": "link", "url": 1}}')

assert doc == Document(content={"link": Link()})

def test_invalid_link_fields_ignored(json_codec):

doc = json_codec.load(b'{"_type": "document", "link": {"_type": "link", "fields": 1}}')

assert doc == Document(content={"link": Link()})

def test_invalid_message_field_ignored(json_codec):

error = json_codec.load(b'{"_type": "error", "messages": 1}')

assert error == Error(messages=[])

# Tests for 'Content-Type' header lookup.

def test_get_default_decoder():

assert isinstance(negotiate_decoder(), CoreJSONCodec)

def test_get_supported_decoder():

assert isinstance(negotiate_decoder('application/vnd.coreapi+json'), CoreJSONCodec)

def test_get_supported_decoder_with_parameters():

assert isinstance(negotiate_decoder('application/vnd.coreapi+json; verison=1.0'), CoreJSONCodec)

def test_get_unsupported_decoder():

with pytest.raises(ParseError):

negotiate_decoder('application/csv')

def test_get_render_only_decoder():

with pytest.raises(ParseError):

negotiate_decoder('text/html')

# Tests for 'Accept' header lookup.

def test_get_default_encoder():

codec = negotiate_encoder()

assert isinstance(codec, CoreJSONCodec)

def test_encoder_preference():

codec = negotiate_encoder(

accept='text/html; q=1.0, application/vnd.coreapi+json; q=1.0'

)

assert isinstance(codec, CoreJSONCodec)

def test_get_accepted_encoder():

codec = negotiate_encoder(accept='application/vnd.coreapi+json')

assert isinstance(codec, CoreJSONCodec)

def test_get_underspecified_encoder():

codec = negotiate_encoder(accept='text/*')

assert isinstance(codec, HTMLCodec)

def test_get_unsupported_encoder():

with pytest.raises(NotAcceptable):

negotiate_encoder('application/csv')

def test_get_unsupported_encoder_with_fallback():

codec = negotiate_encoder(accept='application/csv, */*')

assert isinstance(codec, CoreJSONCodec)

# Tests for HTML rendering

def test_html_document_rendering(html_codec):

doc = Document({'string': 'abc', 'int': 123, 'bool': True})

content = html_codec.dump(doc)

assert 'coreapi-document' in content

assert '<span>abc</span>' in content

assert '<code>123</code>' in content

assert '<code>true</code>' in content

def test_html_object_rendering(html_codec):

doc = Document({'object': {'a': 1, 'b': 2}})

content = html_codec.dump(doc)

assert 'coreapi-object' in content

assert '<th>a</th>' in content

assert '<th>b</th>' in content

def test_html_array_rendering(html_codec):

doc = Document({'array': [1, 2]})

content = html_codec.dump(doc)

assert 'coreapi-array' in content

assert '<th>0</th>' in content

assert '<th>1</th>' in content

def test_html_link_rendering(html_codec):

doc = Document({'link': Link(url='/test/')})

content = html_codec.dump(doc)

assert 'coreapi-link' in content

assert 'href="/test/"' in content

def test_html_error_rendering(html_codec):

doc = Error(['something failed'])

content = html_codec.dump(doc)

assert 'coreapi-error' in content

assert 'something failed' in content