def test_save_appends(self):
recs = util.runCoroutine(self.datamgr.sync())
arec = util.runCoroutine(self.datamgr.save([{"team": "NX"}]))
recs.extend(arec)
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(len(dbrecs), len(recs), "record count differs")
self.assertEqual(dbrecs, recs, "db records differ")
def test_sync_initializes_collection_two_teams(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"roster_kc.json"), "rt") as fp:
rstdata = json.load(fp)
with open(
os.path.join(os.path.dirname(__file__), "data",
"roster_pit.json"), "rt") as fp:
rstdata.extend(json.load(fp))
with open(
os.path.join(os.path.dirname(__file__), "data",
"player_gamelog_kc.json"), "rt") as fp:
srcdata = json.load(fp)
with open(
os.path.join(os.path.dirname(__file__), "data",
"player_gamelog_pit.json"), "rt") as fp:
srcdata.extend(json.load(fp))
rmgr = self._getMockPlayerGamelogManager(rosterData=rstdata,
gamelogData=srcdata)
recs = util.runCoroutine(rmgr.sync())
self.assertEqual(len(recs), len(srcdata),
"sync returned record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self._compareGL(dbrecs, recs)
self.assertEqual(rmgr._apiClient.getRequestedRosters(), rstdata,
"requested rosters differs")
def test_sync_updates_nothing_with_no_team_change(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"roster_kc.json"), "rt") as fp:
rstdata = json.load(fp)
with open(
os.path.join(os.path.dirname(__file__), "data",
"roster_pit.json"), "rt") as fp:
rstdata.extend(json.load(fp))
with open(
os.path.join(os.path.dirname(__file__), "data",
"player_gamelog_kc.json"), "rt") as fp:
srcdata = json.load(fp)
with open(
os.path.join(os.path.dirname(__file__), "data",
"player_gamelog_pit.json"), "rt") as fp:
srcdata.extend(json.load(fp))
rmgr = self._getMockPlayerGamelogManager(rosterData=rstdata,
gamelogData=srcdata)
recs = util.runCoroutine(rmgr.sync())
rmgr = self._getMockPlayerGamelogManager(rosterData=rstdata,
gamelogData=srcdata,
dataExpired=False)
recs = util.runCoroutine(rmgr.sync())
self.assertEqual(len(recs), 0, "sync returned record count differs")
self.assertEqual(rmgr._apiClient.getRequestedRosters(), [],
"requested rosters differs")
def test_sync_new_finished_adds(self):
schdata1 = self._getScheduleData()
schdata2 = schdata1.copy()
reqsch2 = []
for r in schdata2:
if not r["finished"]:
r["finished"] = True
reqsch2.append(r)
gsdata1 = self._getGameDriveData([13])
gsdata2 = self._getGameDriveData([14])
gsmgr = self._getMockGameDriveManager(schdata1, gsdata1)
recs1 = util.runCoroutine(gsmgr.sync())
self.assertEqual(len(recs1), len(gsdata1),
"first returned record counts differ")
gsmgr = self._getMockGameDriveManager(schdata2, gsdata2)
recs2 = util.runCoroutine(gsmgr.sync())
self.assertEqual(len(recs2), len(gsdata2),
"second returned record counts differ")
dbrecs = util.runCoroutine(gsmgr.find())
recs = recs1 + recs2
for r in recs:
del r["_id"]
self.assertEqual(len(dbrecs), len(recs), "db record counts differ")
self.assertEqual(dbrecs, recs, "db records differ")
apireqs = gsmgr._apiClient.getRequestedSchedules()
self.assertEqual(len(apireqs), len(reqsch2),
"api request record counts differ")
self.assertEqual(apireqs, reqsch2, "api request records differ")
def test_parseNameAbbreviation(self):
abbr = "C.Wollam"
self.assertEqual(util.parseNameAbbreviation(abbr), ("^c.*", "^wollam"),
abbr)
abbr = "C Wollam"
self.assertEqual(util.parseNameAbbreviation(abbr), ("^c.*", "^wollam"),
abbr)
abbr = "C.Wollam Jr."
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^wollam( *jr)*"), abbr)
abbr = "C Wollam Jr."
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^wollam( *jr)*"), abbr)
abbr = "C.Wollam Jr"
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^wollam( *jr)*"), abbr)
abbr = "C Wollam Jr"
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^wollam( *jr)*"), abbr)
abbr = "C.Wollam II"
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^wollam( *ii)*"), abbr)
abbr = "C Wollam II"
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^wollam( *ii)*"), abbr)
abbr = "C.St. Wollam"
self.assertEqual(util.parseNameAbbreviation(abbr),
("^c.*", "^st[\\. ]*wollam"), abbr)
abbr = "TOUCHBACK"
self.assertEqual(util.parseNameAbbreviation(abbr),
(None, "^touchback"), abbr)
def test_player_gamelog(self):
pmgr = PlayerGamelogManagerFacade(self.entmgr)
recs = util.runCoroutine(pmgr.sync())
dbrecs = util.runCoroutine(pmgr.find())
self.assertEqual(len(dbrecs), len(recs), "db records lengths differ")
self.assertGreater(len([r for r in dbrecs if "previous_teams" in r]),
0, "previous_teams not set")
def test_sync_req_unfinished_only_after_initialized_in_regseason(self):
srcdata = []
updata = []
tddpath = os.path.join(os.path.dirname(__file__), "data")
for fname in [
"schedule_2017.json", "schedule_2018.json",
"schedule_2019.json"
]:
with open(os.path.join(tddpath, fname), "rt") as fp:
data = json.load(fp)
srcdata.extend(data)
if fname == "schedule_2019.json":
updata = [rec for rec in data if not rec["finished"]]
xreq = []
for week in range(14, 18):
xreq.append({
"season": 2019,
"season_type": "regular_season",
"week": week
})
smgr = self._getMockScheduleManager(scheduleData=srcdata)
recs1 = util.runCoroutine(smgr.sync())
self.assertEqual(len(recs1), len(srcdata),
"sync1 returned record count differs")
smgr = self._getMockScheduleManager(scheduleData=srcdata)
recs2 = util.runCoroutine(smgr.sync())
self.assertEqual(len(recs2), len(updata),
"sync2 returned record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(dbrecs, recs1, "db records differ")
apireq = smgr._apiClient.getRequestedData()
self.assertEqual(len(apireq), len(xreq), "api request lengths differ")
self.assertEqual(apireq, xreq, "api requests differ")
def test_sync_only_inserts_new(self):
recs = util.runCoroutine(self.datamgr.sync())
self.assertGreater(len(recs), 0, "sync returned 0 records")
recs2 = util.runCoroutine(self.datamgr.sync())
self.assertEqual(len(recs2), 0, "sync returned 0 records")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(dbrecs, recs, "db records differ")
def test_game_play(self):
mgr = GamePlayManagerFacade(self.entmgr)
recs = util.runCoroutine(mgr.sync())
writeData(mgr._getAmbiguousPlayerAbbrevs(),
"game_play_ambig_plabb.json")
writeData(mgr._getMissingPlayerAbbrevs(), "game_play_miss_plabb.json")
dbrecs = util.runCoroutine(mgr.find())
self.assertEqual(len(dbrecs), len(recs), "db records lengths differ")
def test_roster(self):
rmgr = RosterManagerFacade(self.entmgr)
recs = util.runCoroutine(rmgr.sync())
dbrecs = util.runCoroutine(rmgr.find())
self.assertLessEqual(len(dbrecs), len(recs),
"db records lengths differ")
self.assertGreater(len([r for r in dbrecs if "previous_teams" in r]),
0, "previous_teams not set")
def test_sync_initializes_collection_one_team(self):
with open(os.path.join(os.path.dirname(__file__), "data", "roster_kc.json"), "rt") as fp:
srcdata = json.load(fp)
rmgr = self._getMockRosterManager(teamData=[{"team": "KC"}], rosterData=srcdata)
recs = util.runCoroutine(rmgr.sync())
self.assertEqual(len(recs), len(srcdata), "sync returned record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(dbrecs, recs, "db records differ")
self.assertEqual(rmgr._apiClient.getRequestedTeams(), set(["KC"]), "requested teams differs")
def test_find_by_teams(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"schedule_2017.json"), "rt") as fp:
srcdata = json.load(fp)
smgr = self._getMockScheduleManager(scheduleData=srcdata)
util.runCoroutine(smgr.sync())
recs = util.runCoroutine(smgr.find(teams=["ATL"]))
self.assertEqual(len(recs), 22, "ATL record count differs")
recs = util.runCoroutine(smgr.find(teams=["ATL", "NE"]))
self.assertEqual(len(recs), 44, "ATL, NE record count differs")
def test_find_constraint(self):
recs = util.runCoroutine(
self.entmgr.save(self.entityName, [{
"team": "KC"
}, {
"team": "PIT"
}]))
for rec in recs:
del rec["_id"]
dbrecs = util.runCoroutine(self.datamgr.find(teams=["KC"]))
self.assertEqual(dbrecs, [recs[0]], "db records differ")
def test_find_by_finished(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"schedule_2019.json"), "rt") as fp:
srcdata = json.load(fp)
smgr = self._getMockScheduleManager(scheduleData=srcdata)
util.runCoroutine(smgr.sync())
recs = util.runCoroutine(smgr.find(finished=True))
self.assertEqual(len(recs), 32, "True record count differs")
recs = util.runCoroutine(smgr.find(finished=False))
self.assertEqual(len(recs), 8, "False record count differs")
def test_sync_no_new_finished_noop(self):
schdata = self._getScheduleData()
gsdata = self._getGameDriveData([13])
gsmgr = self._getMockGameDriveManager(schdata, gsdata)
recs1 = util.runCoroutine(gsmgr.sync())
self.assertEqual(len(recs1), len(gsdata),
"first returned record counts differ")
recs2 = util.runCoroutine(gsmgr.sync())
self.assertEqual(len(recs2), 0, "second returned record counts differ")
dbrecs = util.runCoroutine(gsmgr.find())
self.assertEqual(len(dbrecs), len(recs1), "db record counts differ")
def test_delete_profile_id(self):
with open(os.path.join(os.path.dirname(__file__), "data", "roster_kc.json"), "rt") as fp:
srcdata = json.load(fp)
rmgr = self._getRosterManager()
recs = util.runCoroutine(rmgr.save(srcdata))
self.assertEqual(len(recs), len(srcdata), "save returned record count differs")
dcount = util.runCoroutine(rmgr.delete(profile_ids=[2562399]))
self.assertEqual(dcount, 1, "delete returned record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(len(dbrecs), len(srcdata) - 1, "db record count differs")
xdata = [_ for _ in srcdata if _["profile_id"] != 2562399]
self.assertEqual(dbrecs, xdata, "db records differ")
def test_find_by_season_type(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"schedule_2017.json"), "rt") as fp:
srcdata = json.load(fp)
smgr = self._getMockScheduleManager(scheduleData=srcdata)
util.runCoroutine(smgr.sync())
recs = util.runCoroutine(smgr.find(season_types=["regular_season"]))
self.assertEqual(len(recs), 31, "regular_season record count differs")
recs = util.runCoroutine(
smgr.find(season_types=["regular_season", "postseason"]))
self.assertEqual(len(recs), 36,
"regular_season, postseason record count differs")
def test_save_appends(self):
with open(os.path.join(os.path.dirname(__file__), "data", "roster_kc.json"), "rt") as fp:
kcdata = json.load(fp)
with open(os.path.join(os.path.dirname(__file__), "data", "roster_pit.json"), "rt") as fp:
pitdata = json.load(fp)
rmgr = self._getMockRosterManager(teamData=[{"team": "KC"}], rosterData=kcdata.copy())
recs = util.runCoroutine(rmgr.sync())
self.assertEqual(len(recs), len(kcdata), "sync record count differs")
recs.extend(util.runCoroutine(rmgr.save(pitdata.copy())))
self.assertEqual(len(recs), len(kcdata) + len(pitdata), "save record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(len(dbrecs), len(recs), "db record count differs")
self.assertEqual(dbrecs, recs, "db records differ")
def test_save_adds_teams(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"schedule_2017.json"), "rt") as fp:
srcdata = json.load(fp)
d = srcdata[0]
smgr = ScheduleManagerFacade(self.entmgr)
recs = util.runCoroutine(smgr.save([d]))
self.assertEqual(len(recs), 1, "returned record count differs")
self.assertTrue("teams" in recs[0], "teams not added")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(dbrecs, recs, "db records differ")
self.assertEqual(dbrecs[0]["teams"], ["MIA", "ATL"],
"teams value differs")
def test_find_by_season(self):
srcdata = []
tddpath = os.path.join(os.path.dirname(__file__), "data")
for fname in [
"schedule_2017.json", "schedule_2018.json",
"schedule_2019.json"
]:
with open(os.path.join(tddpath, fname), "rt") as fp:
srcdata.extend(json.load(fp))
smgr = self._getMockScheduleManager(scheduleData=srcdata)
util.runCoroutine(smgr.sync())
recs = util.runCoroutine(smgr.find(seasons=[2017]))
self.assertEqual(len(recs), 44, "2017 record count differs")
recs = util.runCoroutine(smgr.find(seasons=[2017, 2019]))
self.assertEqual(len(recs), 84, "2017, 2019 record count differs")
def test_sync_only_updates_records_with_team_change(self):
with open(
os.path.join(os.path.dirname(__file__), "data",
"roster_kc.json"), "rt") as fp:
rstdata = json.load(fp)
with open(
os.path.join(os.path.dirname(__file__), "data",
"roster_pit.json"), "rt") as fp:
rstdata.extend(json.load(fp))
with open(
os.path.join(os.path.dirname(__file__), "data",
"player_gamelog_kc.json"), "rt") as fp:
srcdata = json.load(fp)
with open(
os.path.join(os.path.dirname(__file__), "data",
"player_gamelog_pit.json"), "rt") as fp:
srcdata.extend(json.load(fp))
rmgr = self._getMockPlayerGamelogManager(rosterData=rstdata,
gamelogData=srcdata)
recs = util.runCoroutine(rmgr.sync())
xreqrec = []
for rec in rstdata:
if rec["profile_id"] == 2560950:
rec["team"] = "KC"
xreqrec.append(rec)
xrec = []
for rec in srcdata:
if rec["profile_id"] == 2560950:
rec["team"] = "KC"
crec = rec.copy()
# Since the team is changing the previous_teams attribute should be set
crec["previous_teams"] = ["PIT"]
xrec.append(crec)
rmgr = self._getMockPlayerGamelogManager(rosterData=rstdata,
gamelogData=srcdata,
dataExpired=False)
recs = util.runCoroutine(rmgr.sync())
reqrec = rmgr._apiClient.getRequestedRosters()
self.assertEqual(len(reqrec), len(xreqrec),
"requested roster lengths differs")
self.assertEqual(reqrec, xreqrec, "requested rosters differs")
self.assertEqual(len(recs), 24, "sync returned record count differs")
dbrecs = util.runCoroutine(
self.entmgr.find(self.entityName,
query={"profile_id": 2560950},
projection={"_id": False}))
self.assertEqual(len(dbrecs), 24, "db record counts differ")
self._compareGL(dbrecs, xrec)
def test_sync_initializes_collection_with_historic_data_with_previous_team(self):
with open(os.path.join(os.path.dirname(__file__), "data", "roster_kc.json"), "rt") as fp:
srcdata = json.load(fp)
with open(os.path.join(os.path.dirname(__file__), "data", "roster_kc.json"), "rt") as fp:
histdata = json.load(fp)
for rec in histdata:
rec["team"] = "PIT"
rmgr = self._getMockRosterManager(teamData=[{"team": "KC"}], rosterData=srcdata, historicData=histdata)
recs = util.runCoroutine(rmgr.sync())
self.assertEqual(len(recs), len(srcdata) + len(histdata), "sync returned record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
self.assertEqual(len(dbrecs), len(srcdata), "db record count differs")
for rec in dbrecs:
self.assertTrue("previous_teams" in rec, "previous_teams not added to {}".format(rec["profile_id"]))
self.assertEqual(rec["previous_teams"], ["PIT"], "previous_teams value not equal for {}".format(rec["profile_id"]))
self.assertEqual(rmgr._apiClient.getRequestedTeams(), set(["KC"]), "requested teams differs")
def __init__(self,
dbHost=os.environ["DB_HOST"],
dbPort=int(os.environ["DB_PORT"]),
dbAuthName=(os.environ["DB_AUTH_NAME"]
if "DB_AUTH_NAME" in os.environ else ""),
dbName=os.environ["DB_NAME"],
dbUser=os.environ["DB_USER"],
dbUserPwd=os.environ["DB_USER_PWD"],
dbSSL=("DB_USE_SSL" in os.environ
and util.str2bool(os.environ["DB_USE_SSL"])),
dbReplicaSet=(os.environ["DB_REPL_SET"]
if "DB_REPL_SET" in os.environ else ""),
dbAppName=(os.environ["DB_APP_NAME"]
if "DB_APP_NAME" in os.environ else "")):
self._entity_manager = EntityManager(dbHost, dbPort, dbAuthName,
dbName, dbUser, dbUserPwd, dbSSL,
dbReplicaSet, dbAuthName)
self._nflapi = nflapi.Client.Client()
self._team_mgr = None
self._roster_mgr = None
self._sched_mgr = None
self._plprof_mgr = None
self._plgmlg_mgr = None
self._gmsum_mgr = None
self._gmscr_mgr = None
self._gmdrv_mgr = None
self._gmplay_mgr = None
def test_ddquery_diff_q_keys_some(self):
q = [{"col1": "a", "col3": "a"}]
d = [{"col1": "a", "col2": 1}]
self.assertEqual(util.ddquery(q, d), (
[],
d,
))
def test_ddquery_1q_1md(self):
q = [{"col1": "a"}]
d = [{"col1": "a", "col2": 1}]
self.assertEqual(util.ddquery(q, d), (
d,
[],
))
def test_ddquery_1q_1md_1nmd(self):
q = [{"col1": "a"}]
d = [{"col1": "a", "col2": 1}, {"col1": "b", "col2": 1}]
self.assertEqual(util.ddquery(q, d), (
[d[0]],
[d[1]],
))
def _getQueryModel(self, **kwargs) -> QueryModel:
qm = QueryModel()
if "teams" in kwargs and kwargs["teams"] is not None:
qm.cstart("team", kwargs["teams"], Operator.IN)
if "include_previous_teams" in kwargs and kwargs[
"include_previous_teams"]:
qm.cor("previous_teams", kwargs["teams"], Operator.IN)
cmap = {
"position":
kwargs["positions"] if "positions" in kwargs else None,
"last_name":
kwargs["last_names"] if "last_names" in kwargs else None,
"first_name":
kwargs["first_names"] if "first_names" in kwargs else None,
"profile_id":
kwargs["profile_ids"] if "profile_ids" in kwargs else None
}
for name in cmap:
if cmap[name] is not None:
qm.cand(name, cmap[name], Operator.IN)
if "player_abbreviations" in kwargs and kwargs[
"player_abbreviations"] is not None:
paqm = QueryModel()
for pabb in kwargs["player_abbreviations"]:
if not (pabb is None or pabb == ""):
curqm = QueryModel()
fi, ln = util.parseNameAbbreviation(pabb)
if not (fi is None and ln is None):
if fi is not None:
curqm.cstart("first_name", fi, Operator.REGEX, "i")
curqm.cand("last_name", ln, Operator.REGEX, "i")
paqm.cor(query_model=curqm)
qm.cand(query_model=paqm)
return qm
def test_sync_initializes_collection(self):
schdata = self._getScheduleData()
gsdata = self._getGameDriveData()
gsmgr = self._getMockGameDriveManager(schdata, gsdata)
recs = util.runCoroutine(gsmgr.sync())
self.assertEqual(len(recs), len(gsdata),
"returned record counts differ")
dbrecs = util.runCoroutine(gsmgr.find())
for r in recs:
del r["_id"]
self.assertEqual(len(dbrecs), len(recs), "db record counts differ")
self.assertEqual(dbrecs, recs, "db records differ")
apireqs = gsmgr._apiClient.getRequestedSchedules()
self.assertEqual(len(apireqs), len(schdata),
"api request record counts differ")
self.assertEqual(apireqs, schdata, "api request records differ")
def __init__(self,
dbHost=os.environ["DB_HOST"],
dbPort=int(os.environ["DB_PORT"]),
dbAuthName=(os.environ["DB_AUTH_NAME"]
if "DB_AUTH_NAME" in os.environ else ""),
dbName=os.environ["DB_NAME"],
dbUser=os.environ["DB_USER"],
dbUserPwd=os.environ["DB_USER_PWD"],
dbSSL=("DB_USE_SSL" in os.environ
and util.str2bool(os.environ["DB_USE_SSL"])),
dbReplicaSet=(os.environ["DB_REPL_SET"]
if "DB_REPL_SET" in os.environ else ""),
dbAppName=(os.environ["DB_APP_NAME"]
if "DB_APP_NAME" in os.environ else ""),
entityDirPath: str = None):
"""Create a new EntityManager object"""
self._db_host = dbHost
self._db_port = dbPort
if not (dbAuthName is None or dbAuthName == ""):
self._db_auth_name = dbAuthName
else:
self._db_auth_name = dbName
self._db_name = dbName
self._db_user = dbUser
self._db_user_pwd = dbUserPwd
self._conn = None
self._db = None
if entityDirPath is None:
entityDirPath = os.path.join(os.path.dirname(__file__), "entity")
self._entity_dir_path = entityDirPath
self._ssl = dbSSL
self._repl_set = dbReplicaSet
self._app_name = dbAppName
self._entityCache = {}
self._connect()
def test_sync_req_postseason_only_after_initialized_after_regseason(self):
srcdata = []
psdata = []
tddpath = os.path.join(os.path.dirname(__file__), "data")
for fname in [
"schedule_2017.json", "schedule_2018.json",
"schedule_2019.json"
]:
with open(os.path.join(tddpath, fname), "rt") as fp:
data = json.load(fp)
srcdata.extend(data)
if fname == "schedule_2018.json":
# use the 2018 postseason data as the 2019 postseason data
for d in [
r for r in data if r["season_type"] == "postseason"
]:
ud = d.copy()
ud["finished"] = False
ud["season"] = 2019
ud["gsis_id"] = ud["gsis_id"].replace(
"2019", "2020", 1)
psdata.append(ud)
for rec in srcdata:
if not rec["finished"]:
rec["finished"] = True
xreq = []
for week in range(1, 5):
xreq.append({
"season": 2019,
"season_type": "postseason",
"week": week
})
smgr = self._getMockScheduleManager(scheduleData=srcdata)
recs1 = util.runCoroutine(smgr.sync())
self.assertEqual(len(recs1), len(srcdata),
"sync1 returned record count differs")
smgr = self._getMockScheduleManager(scheduleData=psdata)
recs2 = util.runCoroutine(smgr.sync())
self.assertEqual(len(recs2), len(psdata),
"sync2 returned record count differs")
dbrecs = util.runCoroutine(self.entmgr.find(self.entityName))
xdbrecs = recs1 + recs2
self.assertEqual(len(dbrecs), len(xdbrecs), "db record lengths differ")
self.assertEqual(dbrecs, xdbrecs, "db records differ")
apireq = smgr._apiClient.getRequestedData()
self.assertEqual(len(apireq), len(xreq), "api request lengths differ")
self.assertEqual(apireq, xreq, "api requests differ")
