def test_bad_series_validate(talker: Session) -> None:
"""Test data with invalid data."""
# Change the 'name' field to an int, when it should be a string.
data = {
"id": 150,
"name": 50,
"sort_name": "Gunhawks",
"volume": 1,
"series_type": {"id": 5, "name": "One-Shot"},
"publisher": 1,
"year_began": 2019,
"year_end": 2019,
"desc": "",
"issue_count": 1,
"modified": "2019-07-05T14:32:52.256872-04:00",
"image": "https://static.metron.cloud/media/issue/2019/02/06/gunhawks-1.jpg",
}
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/series/150/",
text=json.dumps(data),
)
with pytest.raises(exceptions.ApiError):
talker.series(150)
def test_bad_character_validate(talker: Session) -> None:
"""Test data with invalid data."""
# Change the 'name' field to an int, when it should be a string.
data = {
"id":
150,
"name":
50,
"alias": [],
"desc":
"Foo",
"image":
"https://static.metron.cloud/media/character/2018/11/15/moon-knight.jpg",
"creators": [{
"id": 146,
"name": "Doug Moench",
"modified": "2019-06-23T15:13:21.994966-04:00"
}],
"teams": [],
"modified":
"2020-07-29T17:48:36.347982-04:00",
}
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/character/150/",
text=json.dumps(data),
)
with pytest.raises(exceptions.ApiError):
talker.character(150)
def test_bad_issue(talker: Session) -> None:
"""Test for a non-existant issue."""
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/issue/-1/",
text='{"response_code": 404, "detail": "Not found."}',
)
with pytest.raises(exceptions.ApiError):
talker.issue(-1)
def test_bad_arc(talker: Session) -> None:
"""Test for bad arc requests."""
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/arc/-8/",
text='{"response_code": 404, "detail": "Not found."}',
)
with pytest.raises(exceptions.ApiError):
talker.arc(-8)
def test_issue_with_variants(talker: Session) -> None:
"""Test issue with variant data."""
paprika = talker.issue(37094)
assert paprika.series.id == 2511
assert paprika.series.name == "Mirka Andolfo's Sweet Paprika"
assert paprika.volume == 1
assert paprika.number == "2"
assert paprika.cover_date == date(2021, 9, 1)
assert paprika.store_date == date(2021, 9, 1)
assert paprika.price == Decimal("3.99")
assert paprika.sku == "JUN210256"
assert paprika.page_count is None
assert len(paprika.credits) == 9
assert len(paprika.variants) == 4
assert paprika.variants[0].name == "Cover B Sejic"
assert paprika.variants[0].sku == "JUN210257"
assert (
paprika.variants[0].image ==
"https://static.metron.cloud/media/variants/2021/08/26/sweet-paprika-2b.jpg"
)
assert paprika.variants[1].name == "Cover C March"
assert paprika.variants[1].sku == "JUN210258"
assert (
paprika.variants[1].image ==
"https://static.metron.cloud/media/variants/2021/08/26/sweet-paprika-2c.jpg"
)
def test_issue_with_price_and_sku(talker: Session) -> None:
"""Test issue with price & sku values."""
die_16 = talker.issue(36860)
assert die_16.price == Decimal("3.99")
assert die_16.sku == "JUN210207"
assert die_16.cover_date == date(2021, 8, 1)
assert die_16.store_date == date(2021, 8, 25)
def test_arc_issue_list(talker: Session) -> None:
"""Test for getting an issue list for an arc."""
issues = talker.arc_issues_list(177)
assert len(issues) == 7
assert issues[0].id == 6798
assert issues[0].issue_name == "Batman (2011) #1"
assert issues[0].cover_date == date(2011, 11, 1)
def test_character_issue_list(talker: Session) -> None:
"""Test for getting an issue list for an arc."""
issues = talker.character_issues_list(1)
assert len(issues) == 336
assert issues[0].id == 258
assert issues[0].issue_name == "Fantastic Four (1961) #45"
assert issues[0].cover_date == date(1965, 12, 1)
def test_issue_with_upc_sku_price(talker: Session) -> None:
"""Test issue with upc, sku, and price values."""
usca_3 = talker.issue(36812)
assert usca_3.series.name == "The United States of Captain America"
assert usca_3.number == "3"
assert usca_3.price == Decimal("4.99")
assert usca_3.sku == "JUN210696"
assert usca_3.upc == "75960620100600311"
def test_series_with_associated_series(talker: Session) -> None:
"""Test series with an associated series link."""
ff = talker.series(2818)
assert ff.name == "Fantastic Four Annual"
assert len(ff.associated) == 1
assoc = ff.associated[0]
assert assoc.id == 26
assert assoc.name == "Fantastic Four (1961)"
def test_characterlist(talker: Session) -> None:
"""Test the CharactersList."""
character = talker.characters_list({"name": "man"})
character_iter = iter(character)
assert next(character_iter).name == "'Mazing Man"
assert next(character_iter).name == "3-D Man (Chandler)"
assert next(character_iter).name == "3-D Man (Garrett)"
assert len(character) == 490
assert character[2].name == "3-D Man (Garrett)"
def test_role_list(talker: Session) -> None:
"""Test the RoleList."""
roles = talker.role_list({"name": "editor"})
role_iter = iter(roles)
assert next(role_iter).name == "Editor"
assert next(role_iter).name == "Consulting Editor"
assert next(role_iter).name == "Assistant Editor"
assert len(roles) == 10
assert roles[1].name == "Consulting Editor"
def test_publisherlist(talker: Session) -> None:
"""Test the PublishersList."""
publishers = talker.publishers_list()
publisher_iter = iter(publishers)
assert next(publisher_iter).name == "12-Gauge Comics"
assert next(publisher_iter).name == "AWA Studios"
assert next(publisher_iter).name == "AfterShock Comics"
assert len(publishers) == 45
assert publishers[2].name == "AfterShock Comics"
def test_bad_arc_validate(talker: Session) -> None:
"""Test data with invalid data."""
# Change the 'name' field to an int, when it should be a string.
data = {
"id": 5,
"name": 10,
"desc": "Foo Bar",
"image": "https://static.metron.cloud/media/arc/2018/11/25/ff-26.jpg",
"modified": "2019-06-23T15:13:19.432378-04:00",
}
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/arc/500/",
text=json.dumps(data),
)
with pytest.raises(exceptions.ApiError):
talker.arc(500)
def test_arcslist(talker: Session) -> None:
"""Test for ArcsList."""
arcs = talker.arcs_list()
arc_iter = iter(arcs)
assert next(arc_iter).name == "'Til Death Do Us..."
assert next(arc_iter).name == "2099"
assert next(arc_iter).name == "52"
assert len(arcs) == 679
assert arcs[2].name == "52"
def test_teamlist(talker: Session) -> None:
"""Test the TeamsList."""
teams = talker.teams_list()
team_iter = iter(teams)
assert next(team_iter).name == "A-Force"
assert next(team_iter).name == "A-Next"
assert next(team_iter).name == "A.I.M."
assert len(teams) == 503
assert teams[2].name == "A.I.M."
def test_issueslist_with_params(talker: Session) -> None:
"""Test the IssueList with params given."""
params = {
"series_name": "Kang",
}
issues = talker.issues_list(params=params)
assert len(issues) == 5
assert issues[0].issue_name == "Kang The Conqueror (2021) #1"
assert issues[0].cover_date == date(2021, 10, 1)
def test_issue_without_story_title(talker: Session) -> None:
"""Test an issue that does not have a story title."""
redemption = talker.issue(30662)
assert redemption.publisher.name == "AWA Studios"
assert redemption.series.name == "Redemption"
assert redemption.volume == 1
assert len(redemption.story_titles) == 0
assert redemption.cover_date == date(2021, 5, 1)
assert redemption.store_date == date(2021, 5, 19)
assert "Christa Faust" in [c.creator for c in redemption.credits]
def test_issue_genre(talker: Session) -> None:
"""Test issue with genre."""
tt = talker.issue(49491)
assert len(tt.series.genres) > 0
assert tt.series.genres[0].name == "Super-Hero"
assert tt.cover_date == date(2011, 11, 1)
assert tt.store_date == date(2011, 9, 28)
assert tt.upc == "76194130522600111"
assert tt.page_count == 36
assert tt.price == Decimal("2.99")
def test_issue_with_page_count(talker: Session) -> None:
"""Test issue that has a page count."""
gr = talker.issue(8118)
assert gr.page_count == 40
assert gr.number == "1"
assert gr.upc == "75960609672500111"
assert gr.cover_date == date(2020, 2, 1)
assert gr.store_date == date(2019, 12, 18)
assert gr.series.name == "Revenge of the Cosmic Ghost Rider"
assert gr.volume == 1
def test_issue_without_store_date(talker: Session) -> None:
"""Test issue that does not have a store date."""
spidey = talker.issue(31047)
assert spidey.publisher.name == "Marvel"
assert spidey.series.name == "The Spectacular Spider-Man"
assert spidey.volume == 1
assert spidey.story_titles[0] == "A Night on the Prowl!"
assert spidey.cover_date == date(1980, 10, 1)
assert spidey.store_date is None
assert "Dennis O'Neil" in [c.creator for c in spidey.credits]
assert "Spider-Man" in [c.name for c in spidey.characters]
def test_multi_page_results(talker: Session) -> None:
"""Test for multi page results."""
issues = talker.issues_list({
"series_name": "action comics",
"series_year_began": 1938
})
assert len(issues) == 864
assert issues[0].issue_name == "Action Comics (1938) #1"
assert issues[0].cover_date == date(1938, 6, 1)
assert issues[863].issue_name == "Action Comics (1938) #904"
assert issues[863].cover_date == date(2011, 10, 1)
def test_serieslist(talker: Session) -> None:
"""Test the SeriesList."""
series = talker.series_list({"name": "batman"})
series_iter = iter(series)
assert next(series_iter).id == 2547
assert next(series_iter).id == 2481
assert next(series_iter).id == 763
assert next(series_iter).id == 93
assert len(series) == 139
assert series[3].id == 93
assert series[3].display_name == "Batman (2016)"
def test_bad_team_validate(talker: Session) -> None:
"""Test data with invalid data."""
# Change the 'name' field to an int, when it should be a string.
data = {
"id": 150,
"name": 50,
"desc": "Foo Bat",
"image": "https://static.metron.cloud/media/team/2019/06/20/aquamarines.jpg",
"creators": [],
"modified": "2019-06-23T15:13:23.927059-04:00",
}
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/team/150/",
text=json.dumps(data),
)
with pytest.raises(exceptions.ApiError):
talker.team(150)
def test_bad_publisher_validate(talker: Session) -> None:
"""Test data with invalid data."""
# Change the 'name' field to an int, when it should be a string.
data = {
"id": 15,
"name": 150,
"founded": 1993,
"desc": "Foo Bar",
"image":
"https://static.metron.cloud/media/publisher/2018/12/02/bongo.png",
"modified": "2019-06-23T15:13:23.581612-04:00",
}
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/publisher/15/",
text=json.dumps(data),
)
with pytest.raises(exceptions.ApiError):
talker.publisher(15)
def test_series_without_year_end(talker: Session) -> None:
"""Test for series without a year-end date."""
abs_carnage = talker.series(2311)
assert abs_carnage.name == "Absolute Carnage"
assert abs_carnage.sort_name == "Absolute Carnage"
assert abs_carnage.volume == 1
assert abs_carnage.year_began == 2019
assert abs_carnage.year_end is None
assert abs_carnage.issue_count == 5
assert abs_carnage.publisher.id == 1
assert abs_carnage.publisher.name == "Marvel"
assert abs_carnage.series_type.name == "Mini-Series"
def test_bad_issue_validate(talker: Session) -> None:
"""Test data with invalid data."""
# Change the 'number' field to an int, when it should be a string.
data = {
"id": 150,
"publisher": {
"id": 2,
"name": "DC Comics"
},
"series": {
"id": 25,
"name": "Mister Miracle"
},
"volume": 1,
"number": 20,
"name": ["Eclipse"],
"cover_date": "1977-10-01",
"store_date": None,
"price": None,
"sku": "",
"upc": "",
"page": None,
"desc": "Scott rescues Barda on the Moon.",
"image": "https://static.metron.cloud/media/issue/2018/11/25/mm20.jpg",
"arcs": [],
"credits": [],
"characters": [],
"teams": [],
"variants": [],
"modified": "2019-06-23T15:13:18.212120-04:00",
}
with requests_mock.Mocker() as r:
r.get(
"https://metron.cloud/api/issue/150/",
text=json.dumps(data),
)
with pytest.raises(exceptions.ApiError):
talker.issue(150)
def test_issueslist(talker: Session) -> None:
"""Test the IssueList."""
issues = talker.issues_list({
"series_name": "action comics",
"series_year_began": 2011
})
issue_iter = iter(issues)
assert next(issue_iter).id == 6730
assert next(issue_iter).id == 6731
assert next(issue_iter).id == 6732
assert len(issues) == 57
assert issues[2].id == 6732
assert issues[56].issue_name == "Action Comics (2011) #52"
def test_issue_with_reprints(talker: Session) -> None:
"""Test issue with reprint information."""
wf = talker.issue(45025)
assert wf.series.name == "World's Finest Comics"
assert wf.number == "228"
assert wf.cover_date == date(1975, 3, 1)
assert wf.price == Decimal(".6")
assert len(wf.reprints) == 3
assert wf.reprints[0].id == 35086
assert wf.reprints[0].issue == "Action Comics (1938) #193"
assert wf.reprints[1].id == 3645
assert wf.reprints[1].issue == "Aquaman (1962) #12"
assert wf.reprints[2].id == 43328
assert wf.reprints[2].issue == "The Brave and the Bold (1955) #58"
def test_known_publishers(talker: Session) -> None:
"""Test for a known publisher."""
marvel = talker.publisher(1)
assert marvel.name == "Marvel"
assert marvel.image == "https://static.metron.cloud/media/publisher/2018/11/11/marvel.jpg"
assert marvel.founded == 1939
assert marvel.modified == datetime(
2019,
6,
23,
15,
13,
23,
591390,
tzinfo=timezone(timedelta(days=-1, seconds=72000), "-0400"),
)