def test_unknown_place_within_country(self):
# Test an authentication document that names an unknown
# place within a country.
sf = MockPlace()
us = MockPlace(inside={"San Francisco": sf})
MockPlace.by_name["US"] = us
self.parse_places({"US": "Nowheresville"},
expected_unknown={"US": ["Nowheresville"]})
def test_name_treated_as_title(self):
"""Some invalid documents put the library name in 'name' instead of title.
We can handle these documents.
"""
document = dict(name="My library")
auth = AuthDoc.from_dict(None, document, MockPlace())
eq_("My library", auth.title)
def test_empty_document(self):
"""Provide an empty Authentication For OPDS document to test
default values.
"""
place = MockPlace()
everywhere = place.everywhere(None)
parsed = AuthDoc.from_string(None, "{}", place)
# In the absence of specific information, it's assumed the
# OPDS server is open to everyone.
eq_(([everywhere], {}, {}), parsed.service_area)
eq_(([everywhere], {}, {}), parsed.focus_area)
eq_([parsed.PUBLIC_AUDIENCE], parsed.audiences)
eq_(None, parsed.id)
eq_(None, parsed.title)
eq_(None, parsed.service_description)
eq_(None, parsed.color_scheme)
eq_(None, parsed.collection_size)
eq_(None, parsed.public_key)
eq_(None, parsed.website)
eq_(False, parsed.online_registration)
eq_(None, parsed.root)
eq_([], parsed.links)
eq_(None, parsed.logo)
eq_(None, parsed.logo_link)
eq_(False, parsed.anonymous_access)
def test_ambiguous_place_within_country(self):
# Test an authentication document that names an ambiguous
# place within a country.
us = MockPlace(inside={"Springfield": MockPlace.AMBIGUOUS})
MockPlace.by_name["US"] = us
self.parse_places({"US": ["Springfield"]},
expected_ambiguous={"US": ["Springfield"]})
def test_anonymous_access(self):
"""You can signal that your OPDS server allows anonymous access by
including it as an authentication type.
"""
document = dict(authentication=[
dict(type="http://opds-spec.org/auth/basic"),
dict(type="https://librarysimplified.org/rel/auth/anonymous")
])
auth = AuthDoc.from_dict(None, document, MockPlace())
eq_(True, auth.anonymous_access)
def test_places_within_country(self):
# Test an authentication document that says a library
# covers one or more places within a country.
# This authentication document covers two places called
# "San Francisco" (one in the US and one in Mexico) as well as a
# place called "Mexico City" in Mexico.
#
# Note that it's invalid to map a country name to a single
# place name (it's supposed to always be a list), but our
# parser can handle it.
doc = {"US": "San Francisco", "MX": ["San Francisco", "Mexico City"]}
place1 = MockPlace()
place2 = MockPlace()
place3 = MockPlace()
place4 = MockPlace()
us = MockPlace(inside={"San Francisco": place1, "San Jose": place2})
mx = MockPlace(inside={"San Francisco": place3, "Mexico City": place4})
MockPlace.by_name["US"] = us
MockPlace.by_name["MX"] = mx
# AuthenticationDocument.parse_coverage is able to turn those
# three place names into place objects.
self.parse_places(doc, expected_places=[place1, place3, place4])
def test_logo_link(self):
"""You can link to your logo, instead of including it in the
document.
"""
document = {
"links": [dict(rel="logo", href="http://logo.com/logo.jpg")]
}
auth = AuthDoc.from_dict(None, document, MockPlace())
eq_(None, auth.logo)
eq_({
"href": "http://logo.com/logo.jpg",
"rel": "logo"
}, auth.logo_link)
def test_unknown_country(self):
# Test an authentication document that says a library covers an
# entire country, but the library registry doesn't know anything about
# that country's geography.
canada = MockPlace()
MockPlace.by_name["CA"] = canada
self.parse_places(
{
"Memory Alpha": self.EVERYWHERE,
"CA": self.EVERYWHERE
},
expected_places=[canada],
expected_unknown={"Memory Alpha": self.EVERYWHERE})
def test_ambiguous_country(self):
# Test the unlikely scenario where an authentication document says a
# library covers an entire country, but it's ambiguous which
# country is being referred to.
canada = MockPlace()
MockPlace.by_name["CA"] = canada
MockPlace.by_name["Europe I think?"] = MockPlace.AMBIGUOUS
self.parse_places(
{
"Europe I think?": self.EVERYWHERE,
"CA": self.EVERYWHERE
},
expected_places=[canada],
expected_ambiguous={"Europe I think?": self.EVERYWHERE})
def test_unscoped_place_is_in_default_nation(self):
# Test an authentication document that names places without
# saying which nation they're in.
ca = MockPlace()
ut = MockPlace()
# Without a default nation on the server side, we can't make
# sense of these place names.
self.parse_places("CA", expected_unknown={"??": "CA"})
self.parse_places(["CA", "UT"], expected_unknown={"??": ["CA", "UT"]})
us = MockPlace(inside={"CA": ca, "UT": ut})
us.abbreviated_name = "US"
MockPlace.by_name["US"] = us
# With a default nation in place, a bare string like "CA"
# is treated the same as a correctly formatted dictionary
# like {"US": ["CA"]}
MockPlace._default_nation = us
self.parse_places("CA", expected_places=[ca])
self.parse_places(["CA", "UT"], expected_places=[ca, ut])
MockPlace._default_nation = None
def test_entire_country(self):
# Test an authentication document that says a library covers an
# entire country.
us = MockPlace()
MockPlace.by_name["US"] = us
self.parse_places({"US": self.EVERYWHERE}, expected_places=[us])
def test_audiences(self):
"""You can specify the target audiences for your OPDS server."""
document = {"audience": ["educational-secondary", "research"]}
auth = AuthDoc.from_dict(None, document, MockPlace())
eq_(["educational-secondary", "research"], auth.audiences)
def test_real_document(self):
"""Test an Authentication For OPDS document that demonstrates
most of the features we're looking for.
"""
document = {
"id":
"http://library/authentication-for-opds-file",
"title":
"Ansonia Public Library",
"links": [{
"rel": "logo",
"href": "data:image/png;base64,some-image-data",
"type": "image/png"
}, {
"rel": "alternate",
"href": "http://ansonialibrary.org",
"type": "text/html"
}, {
"rel": "register",
"href": "http://example.com/get-a-card/",
"type": "text/html"
}, {
"rel": "start",
"href": "http://catalog.example.com/",
"type": "text/html/"
}, {
"rel": "start",
"href": "http://opds.example.com/",
"type": "application/atom+xml;profile=opds-catalog"
}],
"service_description":
"Serving Ansonia, CT",
"color_scheme":
"gold",
"collection_size": {
"eng": 100,
"spa": 20
},
"public_key":
"a public key",
"features": {
"disabled": [],
"enabled":
["https://librarysimplified.org/rel/policy/reservations"]
},
"authentication": [{
"type": "http://opds-spec.org/auth/basic",
"description": "Log in with your library barcode",
"inputs": {
"login": {
"keyboard": "Default"
},
"password": {
"keyboard": "Default"
}
},
"labels": {
"login": "******",
"password": "******"
}
}]
}
place = MockPlace()
everywhere = place.everywhere(None)
parsed = AuthDoc.from_dict(None, document, place)
# Information about the OPDS server has been extracted from
# JSON and put into the AuthenticationDocument object.
eq_("http://library/authentication-for-opds-file", parsed.id)
eq_("Ansonia Public Library", parsed.title)
eq_("Serving Ansonia, CT", parsed.service_description)
eq_("gold", parsed.color_scheme)
eq_({"eng": 100, "spa": 20}, parsed.collection_size)
eq_("a public key", parsed.public_key)
eq_(
{
u'rel': 'alternate',
u'href': u'http://ansonialibrary.org',
u'type': u'text/html'
}, parsed.website)
eq_(True, parsed.online_registration)
eq_(
{
"rel": "start",
"href": "http://opds.example.com/",
"type": "application/atom+xml;profile=opds-catalog"
}, parsed.root)
eq_("data:image/png;base64,some-image-data", parsed.logo)
eq_(None, parsed.logo_link)
eq_(False, parsed.anonymous_access)