def test_rights_status_open_access_link_no_rights_uses_data_source_default(
self):
identifier = IdentifierData(
Identifier.GUTENBERG_ID,
"abcd",
)
# Here's a CirculationData that will create an open-access
# LicensePoolDeliveryMechanism.
link = LinkData(rel=Hyperlink.OPEN_ACCESS_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url)
circulation_data = CirculationData(
data_source=DataSource.GUTENBERG,
primary_identifier=identifier,
links=[link],
)
replace_formats = ReplacementPolicy(formats=True, )
pool, ignore = circulation_data.license_pool(self._db,
self._default_collection)
pool.open_access = False
# Applying this CirculationData to a LicensePool makes it
# open-access.
circulation_data.apply(self._db, pool.collection, replace_formats)
eq_(True, pool.open_access)
eq_(1, pool.delivery_mechanisms.count())
# The delivery mechanism's rights status is the default for
# the data source.
eq_(RightsStatus.PUBLIC_DOMAIN_USA,
pool.delivery_mechanisms[0].rights_status.uri)
# Even if a commercial source like Overdrive should offer a
# link with rel="open access", unless we know it's an
# open-access link we will give it a RightsStatus of
# IN_COPYRIGHT.
identifier = IdentifierData(
Identifier.OVERDRIVE_ID,
"abcd",
)
link = LinkData(rel=Hyperlink.OPEN_ACCESS_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url)
circulation_data = CirculationData(
data_source=DataSource.OVERDRIVE,
primary_identifier=identifier,
links=[link],
)
pool, ignore = circulation_data.license_pool(self._db,
self._default_collection)
pool.open_access = False
circulation_data.apply(self._db, pool.collection, replace_formats)
eq_(RightsStatus.IN_COPYRIGHT,
pool.delivery_mechanisms[0].rights_status.uri)
eq_(False, pool.open_access)
def test_rights_status_open_access_link_no_rights_uses_data_source_default(self):
identifier = IdentifierData(
Identifier.GUTENBERG_ID,
"abcd",
)
link = LinkData(
rel=Hyperlink.OPEN_ACCESS_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url
)
circulation_data = CirculationData(
data_source=DataSource.GUTENBERG,
primary_identifier=identifier,
links=[link],
)
replace = ReplacementPolicy(
formats=True,
)
pool, ignore = circulation_data.license_pool(self._db)
circulation_data.apply(pool, replace)
eq_(True, pool.open_access)
eq_(1, len(pool.delivery_mechanisms))
# The delivery mechanism's rights status is the default for
# the data source.
eq_(RightsStatus.PUBLIC_DOMAIN_USA, pool.delivery_mechanisms[0].rights_status.uri)
# Even if a commercial source like Overdrive should offer a
# link with rel="open access", unless we know it's an
# open-access link we will give it a RightsStatus of
# IN_COPYRIGHT.
identifier = IdentifierData(
Identifier.OVERDRIVE_ID,
"abcd",
)
link = LinkData(
rel=Hyperlink.OPEN_ACCESS_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url
)
circulation_data = CirculationData(
data_source=DataSource.OVERDRIVE,
primary_identifier=identifier,
links=[link],
)
pool, ignore = circulation_data.license_pool(self._db)
circulation_data.apply(pool, replace)
eq_(RightsStatus.IN_COPYRIGHT,
pool.delivery_mechanisms[0].rights_status.uri)
# This will cause the work to be treated as a non-open-access
# work.
eq_(False, pool.open_access)
def test_make_thumbnail_assigns_pool(self):
identifier = IdentifierData(Identifier.GUTENBERG_ID, "1")
#identifier = self._identifier()
#identifier = IdentifierData(type=Identifier.GUTENBERG_ID, identifier=edition.primary_identifier)
edition = self._edition(identifier_id=identifier.identifier)
link = LinkData(
rel=Hyperlink.THUMBNAIL_IMAGE,
href="http://thumbnail.com/",
media_type=Representation.JPEG_MEDIA_TYPE,
)
metadata = Metadata(
data_source=edition.data_source,
primary_identifier=identifier,
links=[link],
)
circulation = CirculationData(data_source=edition.data_source,
primary_identifier=identifier)
metadata.circulation = circulation
metadata.apply(edition)
thumbnail_link = edition.primary_identifier.links[0]
circulation_pool, is_new = circulation.license_pool(self._db)
eq_(thumbnail_link.license_pool, circulation_pool)
def test_rights_status_commercial_link_with_rights(self):
identifier = IdentifierData(
Identifier.OVERDRIVE_ID,
"abcd",
)
link = LinkData(
rel=Hyperlink.DRM_ENCRYPTED_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url,
rights_uri=RightsStatus.IN_COPYRIGHT,
)
format = FormatData(
content_type=link.media_type,
drm_scheme=DeliveryMechanism.ADOBE_DRM,
link=link,
rights_uri=RightsStatus.IN_COPYRIGHT,
)
circulation_data = CirculationData(
data_source=DataSource.OVERDRIVE,
primary_identifier=identifier,
links=[link],
formats=[format],
)
replace = ReplacementPolicy(
formats=True,
)
pool, ignore = circulation_data.license_pool(self._db)
circulation_data.apply(pool, replace)
eq_(False, pool.open_access)
eq_(1, len(pool.delivery_mechanisms))
eq_(RightsStatus.IN_COPYRIGHT, pool.delivery_mechanisms[0].rights_status.uri)
def test_rights_status_open_access_link_with_rights(self):
identifier = IdentifierData(
Identifier.OVERDRIVE_ID,
"abcd",
)
link = LinkData(
rel=Hyperlink.OPEN_ACCESS_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url,
rights_uri=RightsStatus.CC_BY_ND,
)
circulation_data = CirculationData(
data_source=DataSource.OVERDRIVE,
primary_identifier=identifier,
links=[link],
)
replace = ReplacementPolicy(
formats=True,
)
pool, ignore = circulation_data.license_pool(self._db)
circulation_data.apply(pool, replace)
eq_(True, pool.open_access)
eq_(1, len(pool.delivery_mechanisms))
eq_(RightsStatus.CC_BY_ND, pool.delivery_mechanisms[0].rights_status.uri)
def test_rights_status_open_access_link_no_rights(self):
identifier = IdentifierData(
Identifier.OVERDRIVE_ID,
"abcd",
)
link = LinkData(
rel=Hyperlink.OPEN_ACCESS_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url
)
circulation_data = CirculationData(
data_source=DataSource.OVERDRIVE,
primary_identifier=identifier,
links=[link],
)
replace = ReplacementPolicy(
formats=True,
)
pool, ignore = circulation_data.license_pool(self._db)
circulation_data.apply(pool, replace)
eq_(True, pool.open_access)
eq_(1, len(pool.delivery_mechanisms))
# Rights status is generic open access because there's an open access
# link but no other rights info.
eq_(RightsStatus.GENERIC_OPEN_ACCESS, pool.delivery_mechanisms[0].rights_status.uri)
def test_rights_status_default_rights_from_data_source(self):
identifier = IdentifierData(
Identifier.GUTENBERG_ID,
"abcd",
)
link = LinkData(
rel=Hyperlink.DRM_ENCRYPTED_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url
)
circulation_data = CirculationData(
data_source=DataSource.OA_CONTENT_SERVER,
primary_identifier=identifier,
links=[link],
)
replace = ReplacementPolicy(
formats=True,
)
pool, ignore = circulation_data.license_pool(self._db)
circulation_data.apply(pool, replace)
eq_(True, pool.open_access)
eq_(1, len(pool.delivery_mechanisms))
# The rights status is the default for the OA content server.
eq_(RightsStatus.GENERIC_OPEN_ACCESS, pool.delivery_mechanisms[0].rights_status.uri)
def test_license_pool_sets_default_license_values(self):
"""We have no information about how many copies of the book we've
actually licensed, but a LicensePool can be created anyway,
so we can store format information.
"""
identifier = IdentifierData(Identifier.OVERDRIVE_ID, "1")
drm_format = FormatData(
content_type=Representation.PDF_MEDIA_TYPE,
drm_scheme=DeliveryMechanism.ADOBE_DRM,
)
circulation = CirculationData(
data_source=DataSource.OVERDRIVE,
primary_identifier=identifier,
formats=[drm_format],
)
pool, is_new = circulation.license_pool(
self._db,
)
eq_(True, is_new)
# We start with the conservative assumption that we own no
# licenses for the book.
eq_(0, pool.licenses_owned)
eq_(0, pool.licenses_available)
eq_(0, pool.licenses_reserved)
eq_(0, pool.patrons_in_hold_queue)
def test_rights_status_default_rights_from_data_source(self):
identifier = IdentifierData(
Identifier.GUTENBERG_ID,
"abcd",
)
link = LinkData(rel=Hyperlink.DRM_ENCRYPTED_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url)
circulation_data = CirculationData(
data_source=DataSource.OA_CONTENT_SERVER,
primary_identifier=identifier,
links=[link],
)
replace = ReplacementPolicy(formats=True, )
# This pool starts off as not being open-access.
pool, ignore = circulation_data.license_pool(self._db,
self._default_collection)
eq_(False, pool.open_access)
circulation_data.apply(self._db, pool.collection, replace)
# The pool became open-access because it was given a
# link that came from the OS content server.
eq_(True, pool.open_access)
eq_(1, pool.delivery_mechanisms.count())
# The rights status is the default for the OA content server.
eq_(RightsStatus.GENERIC_OPEN_ACCESS,
pool.delivery_mechanisms[0].rights_status.uri)
def test_rights_status_default_rights_passed_in(self):
identifier = IdentifierData(
Identifier.GUTENBERG_ID,
"abcd",
)
link = LinkData(rel=Hyperlink.DRM_ENCRYPTED_DOWNLOAD,
media_type=Representation.EPUB_MEDIA_TYPE,
href=self._url)
circulation_data = CirculationData(
data_source=DataSource.OA_CONTENT_SERVER,
primary_identifier=identifier,
default_rights_uri=RightsStatus.CC_BY,
links=[link],
)
replace = ReplacementPolicy(formats=True, )
pool, ignore = circulation_data.license_pool(self._db,
self._default_collection)
circulation_data.apply(self._db, pool.collection, replace)
eq_(True, pool.open_access)
eq_(1, pool.delivery_mechanisms.count())
# The rights status is the one that was passed in to CirculationData.
eq_(RightsStatus.CC_BY, pool.delivery_mechanisms[0].rights_status.uri)
