def setUp(self):
self.team_1 = Team(
"France", {
"played": 1,
"won": 0,
"drawn": 1,
"lost": 0,
"for": 2,
"against": 2,
"difference": 0,
"points": 1,
"rank": None
})
self.team_2 = Team(
"Germany", {
"played": 1,
"won": 0,
"drawn": 1,
"lost": 0,
"for": 2,
"against": 2,
"difference": 0,
"points": 1,
"rank": None
})
self.match_1 = Match("1", datetime.datetime(2016, 6, 10, 20, 0),
"Stade de France", "A", self.team_1, self.team_2)
self.match_2 = Match("Round of 16",
datetime.datetime(2016, 6, 25, 14,
0), "Parc des Princes", None,
self.team_1, self.team_2)
def test_eventteams_unknown(self):
self.teams_auth.put()
team_list = ['frc254', 'frc971', 'frc604']
request_body = json.dumps(team_list)
# Insert teams into db, otherwise they won't get added (see 072058b)
Team(id='frc254', team_number=254).put()
Team(id='frc971', team_number=971).put()
request_path = '/api/trusted/v1/event/2014casj/team_list/update'
sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest()
response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True)
self.assertEqual(response.status_code, 200)
db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None)
self.assertEqual(len(db_eventteams), 2)
self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams])
self.assertTrue('2014casj_frc971' in [et.key.id() for et in db_eventteams])
self.assertTrue('2014casj_frc604' not in [et.key.id() for et in db_eventteams])
team_list = ['frc254', 'frc100']
request_body = json.dumps(team_list)
sig = md5.new('{}{}{}'.format('321tEsTsEcReT', request_path, request_body)).hexdigest()
response = self.testapp.post(request_path, request_body, headers={'X-TBA-Auth-Id': 'tEsT_id_0', 'X-TBA-Auth-Sig': sig}, expect_errors=True)
self.assertEqual(response.status_code, 200)
db_eventteams = EventTeam.query(EventTeam.event == self.event.key).fetch(None)
self.assertEqual(len(db_eventteams), 1)
self.assertTrue('2014casj_frc254' in [et.key.id() for et in db_eventteams])
self.assertTrue('2014casj_frc100' not in [et.key.id() for et in db_eventteams])
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<page_num:([0-9]*)>', ApiTeamListController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team1 = Team(
id="frc123",
name="SomeName",
team_number=123,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team2 = Team(
id="frc4567",
name="SomeName",
team_number=4567,
nickname="SomeNickname",
address="San Jose, CA, USA",
website="www.website.com",
)
self.team1.put()
self.team2.put()
def setUp(self):
team_1 = Team("Barcelona", 27)
team_2 = Team("Real Madrid", 24)
self.teams = [team_1, team_2]
self.player_1 = Player("Hazard", "Real Madrid", "Forward", 12, 8, 0, 0)
self.player_2 = Player("Rodrygo", "Real Madrid", "Forward", 4, 9, 0, 0)
def test_team2_winner(self):
self.team1 = Team("Team 1", "Edinburgh, Scotland", "Murrayfield",
67000, 4, 0, 4, 0, 4, 1)
self.team2 = Team("Team 2", "Glasgow, Scotland", "Hampden", 52000, 4,
0, 4, 0, 4, 2)
self.fixture = Fixture(self.team1, self.team2)
self.assertEqual(1, self.team1.score)
self.assertEqual(2, self.team2.score)
self.assertEqual(self.fixture.team2.team_name,
self.fixture.determine_winner(self.team1, self.team2))
def prepare_teams():
team1_as_npc = False
team1 = Team('Player 1', team1_as_npc)
answer = ''
while answer not in ['n', 'p']:
answer = input('Wanna fight with NPC [n/N] or other player [p/P]? ').lower().strip()
team2 = Team(name='Player 2' if answer == 'p' else 'CPU',
npc=False if answer == 'p' else True)
print()
return team1, team2
def test_team_ordering(self):
team_a = Team("Alpha 0")
team_b = Team("Beta 0")
# Same score, alphabetical ordering
assert team_a < team_b
team_b.name = "Active"
assert not team_a < team_b
# Different score means score based ordering
team_b.score = 1
assert not team_a < team_b
def setUp(self):
self.game = Game(
"12/07/2021",
"Peffermill",
1,
2,
1,
1,
)
self.team_1 = Team("Grange", "Nike")
self.team_2 = Team("Edinburgh Uni", "Addias")
def setUp(self):
self.team_1 = Team("France")
self.team_1.group_info = {
"played": 1,
"won": 0,
"drawn": 1,
"lost": 0,
"for": 2,
"against": 2,
"difference": 0,
"points": 1,
"rank": None
}
self.team_2 = Team("Germany")
self.team_2.group_info = {
"played": 1,
"won": 0,
"drawn": 1,
"lost": 0,
"for": 2,
"against": 2,
"difference": 0,
"points": 1,
"rank": None
}
self.team_3 = Team("Hungary")
self.team_3.group_info = {
"played": 1,
"won": 0,
"drawn": 0,
"lost": 1,
"for": 1,
"against": 3,
"difference": -2,
"points": 0,
"rank": None
}
self.team_4 = Team("Portugal")
self.team_4.group_info = {
"played": 1,
"won": 1,
"drawn": 0,
"lost": 0,
"for": 3,
"against": 1,
"difference": 2,
"points": 3,
"rank": None
}
self.group_1 = Group("F")
self.group_1.teams = [
self.team_1, self.team_2, self.team_3, self.team_4
]
def test_game_result_ordering(self):
game = Game()
team_a = Team("A 0")
team_b = Team("B 0")
team_c = Team("c 0")
team_a.score = 0
team_b.score = 3
team_c.score = 3
# Ensure team ordering follows through to team list sorting
game.teams = {"A": team_a, "B": team_b, "c": team_c}
assert str(game.results()) == str([team_b, team_c, team_a])
team_b.name = "d"
game.teams["B"].name = "d"
assert str(game.results()) == str([team_c, team_b, team_a])
def setUp(self):
self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(
probability=1)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
self.testbed.init_memcache_stub()
self.testbed.init_user_stub()
self.testbed.init_urlfetch_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
app = webapp2.WSGIApplication([
RedirectRoute(r'/suggest/cad/review',
SuggestDesignsReviewController,
'review-designs',
strict_slash=True),
RedirectRoute(r'/suggest/review',
SuggestReviewHomeController,
'review-home',
strict_slash=True),
],
debug=True)
self.testapp = webtest.TestApp(app)
self.team = Team(
id="frc1124",
team_number=1124,
)
self.team.put()
def _upload_stats(team_name, stats):
query = Team.all()
query.filter('name =', team_name)
result = query.fetch(1)
if len(result) > 0:
for team in result:
team.year = Const.LAST_YEAR
team.offense_passing = stats['offense']['pass']
team.offense_rushing = stats['offense']['rush']
team.offense_first_down = stats['offense']['first_down']
team.defense_passing = stats['defense']['pass']
team.defense_rushing = stats['defense']['rush']
team.defense_first_down = stats['defense']['first_down']
team.put()
else:
team = Team(name=team_name,
year=Const.LAST_YEAR,
offense_passing=stats['offense']['pass'],
offense_rushing=stats['offense']['rush'],
offense_first_down=stats['offense']['first_down'],
defense_passing=stats['defense']['pass'],
defense_rushing=stats['defense']['rush'],
defense_first_down=stats['defense']['first_down'])
team.put()
def test_team_variables(self):
team = Team("A 1")
# initialise a team with name and latest_score but 0 starting score
assert team.name is "A"
assert team.latest is 1
assert team.score is 0
del team
async def organize(self,
ctx,
quiz_type: str = None,
team_size: str = None):
if ctx.channel.name != text(CHANNEL_SETUP):
return
if quiz_type not in ['normal', 'jeopardy', 'only connect']:
quiz_type = 'normal'
if not team_size:
team_size = 2
team_size = min(max(int(team_size), 2), 8)
self._quiz = Quiz(quiz_type, ctx.message.author, team_size)
self._quiz_message = await ctx.send(self._quiz.organization_text())
await self._quiz_message.add_reaction(EMOJI_OK)
await self._quiz_message.add_reaction(EMOJI_ACCEPT)
await self._quiz_message.add_reaction(EMOJI_DECLINE)
try:
for team_id in range(1, team_size + 1):
role = await self._management.get_or_create_role('Team ' +
str(team_id))
team = Team(role, team_id)
self._quiz.add_team(team)
await self._quiz_message.add_reaction(EMOJI_TEAM[team_id - 1])
except Exception as e:
print(e)
await ctx.message.delete()
def get(self, event_key):
datafeed = DatafeedUsfirst()
event = Event.get_by_id(event_key)
new_awards = AwardManipulator.createOrUpdate(datafeed.getEventAwards(event))
if new_awards is None:
new_awards = []
elif type(new_awards) != list:
new_awards = [new_awards]
# create EventTeams
team_ids = set()
for award in new_awards:
for team in award.team_list:
team_ids.add(team.id())
teams = TeamManipulator.createOrUpdate([Team(
id=team_id,
team_number=int(team_id[3:]))
for team_id in team_ids])
if teams:
if type(teams) is not list:
teams = [teams]
event_teams = EventTeamManipulator.createOrUpdate([EventTeam(
id=event_key + "_" + team.key.id(),
event=event.key,
team=team.key,
year=event.year)
for team in teams])
template_values = {
'awards': new_awards,
}
path = os.path.join(os.path.dirname(__file__), '../templates/datafeeds/usfirst_awards_get.html')
self.response.out.write(template.render(path, template_values))
def getEventTeams(self, year, first_eid):
"""
Returns a list of team_numbers attending a particular Event
"""
if type(year) is not int:
raise TypeError("year must be an integer")
teams = []
seen_teams = set()
for page in range(
8
): # Ensures this won't loop forever. 8 pages should be plenty.
url = self.EVENT_TEAMS_URL_PATTERN % (first_eid)
if page != 0:
url += '&page=%s' % page
partial_teams, more_pages = self.parse(url,
UsfirstEventTeamsParser)
teams.extend(partial_teams)
partial_seen_teams = set(
[team['team_number'] for team in partial_teams])
new_teams = partial_seen_teams.difference(seen_teams)
if (not more_pages) or (new_teams == set()):
break
seen_teams = seen_teams.union(partial_seen_teams)
return [
Team(id="frc%s" % team.get("team_number", None),
first_tpid=team.get("first_tpid", None),
first_tpid_year=year,
team_number=team.get("team_number", None)) for team in teams
]
def setUp(self):
app = webapp2.WSGIApplication([
webapp2.Route(r'/<team_key:>',
ApiTeamHistoryDistrictsController,
methods=['GET'])
],
debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(id="frc1124",
name="UberBots",
team_number=1124,
nickname="UberBots")
self.district_team = DistrictTeam(id="2015ne_frc1124",
team=self.team.key,
year=2015,
district_key=ndb.Key(
District, '2015ne'))
self.district = District(id='2015ne', year=2015)
self.team.put()
self.district_team.put()
self.district.put()
def reload(self):
"""Deserialize the JSON teams storage files to __teams."""
try:
with open("league.json", "r", encoding="utf-8") as f:
self.__teams = {k: Team(**v) for k, v in json.load(f).items()}
except FileNotFoundError:
pass
def _get_teams_data(self, y, num_teams):
self.teams = []
for i in range(1, num_teams + 1):
url = "{}/team/{}".format(
BASE_URI, make_team_code(self.sport, self.league_id, i))
team = Team(y, url)
self.teams.append(team)
def Register():
if not isValidEmail(request.form['email']):
return jsonify({'error': 'E-mail inválido'}), 400
if len(request.form['password']) < PASSWORD_MIN_LENGTH:
return jsonify({'error': 'Senha muito curta'}), 400
if len(request.form['password']) > PASSWORD_MAX_LENGTH:
return jsonify({'error': 'Senha muito longa'}), 400
exists = User.query.filter_by(email=request.form['email']).first()
if exists:
return jsonify({'error': 'Email já registrado'}), 400
name = request.form['name']
if not len(name):
return jsonify({'error': 'É necessário informar um nome'}), 400
exists = User.query.filter_by(name=request.form['name']).first()
if exists:
return jsonify({'error': 'Nome já registrado'}), 400
user = User(email=request.form['email'],
password=encrypt(request.form['password']),
name=name,
role_id=2,
regDate=time.time(),
coins=50)
db.session.add(user)
db.session.commit()
team = Team(name='Time de ' + name, user_id=user.id)
db.session.add(team)
db.session.commit()
return jsonify(user.toJSON()), 201
def readDictFromJSON(modelType: str) -> Union[None, dict]:
"""
Returns a dictionary loaded directly from a JSON file.
Package available method that returns a Python dictionary as defined in the relevant JSON file. The function will
return either the dictionary converted into models or a directly loaded JSON dictionary.
:param modelType: Type of model being loaded
:type modelType: string
:return: Dictionary if type is not a model
:rtype: dictionary
:return: None if type is a model
:rtype: None
"""
JSONFile = __JSONFile(modelType)
tempDict = json.load(JSONFile)
JSONFile.close()
if modelType.lower() in MODEL_TYPE_DICT.get('models').get('driverSubset'):
for model in tempDict:
Driver(tempDict[model])
return
elif modelType.lower() in MODEL_TYPE_DICT.get('models').get('teamSubset'):
for model in tempDict:
Team(tempDict[model])
return
elif modelType.lower() in MODEL_TYPE_DICT.get('miscSubset'):
return tempDict
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc281",
name="Michelin / Caterpillar / Greenville Technical College /\
jcpenney / Baldor / ASME / Gastroenterology Associates /\
Laserflex South & Greenville County Schools & Greenville\
Technical Charter High School",
team_number=281,
rookie_year=1999,
nickname="EnTech GreenVillians",
address="Greenville, SC, USA",
website="www.entech.org",
motto = "Infiltrating Young Minds One Robot at a Time",
)
self.team.put()
def test_xml_constructor(self):
ns = {"ns": "http://fantasysports.yahooapis.com/fantasy/v2/base.rng"}
xml = et.parse('./sample-api-responses/get_team.xml').find(
'ns:team', ns)
result = Team.from_xml_api_data(xml)
expected = Team(
**{
"name": "K.E.V.I.N",
"id": 5,
"owner": "Kevin",
"is_my_team": True,
"waiver_priority": 5,
"move_count": 26,
"trade_count": 0,
"matchups": [],
"average_stats": None,
})
self.assertEqual(expected.name, result.name)
self.assertEqual(expected.id, result.id)
self.assertEqual(expected.owner, result.owner)
self.assertEqual(expected.is_my_team, result.is_my_team)
self.assertEqual(expected.waiver_priority, result.waiver_priority)
self.assertEqual(expected.move_count, result.move_count)
self.assertEqual(expected.trade_count, result.trade_count)
self.assertEqual(expected.matchups, result.matchups)
self.assertEqual(expected.average_stats, result.average_stats)
def generate_fixture_list(league):
fixtures = []
sql = "SELECT possible_games.team_1, possible_games.team_2, playlists.round_no FROM possible_games INNER JOIN fixtures ON fixtures.possible_game_id = possible_games.id INNER JOIN playlists ON fixtures.playlist_id = playlists.id INNER JOIN league_types ON league_types.id = playlists.league_type_id INNER JOIN leagues ON league_types.id = leagues.league_type_id WHERE leagues.id = %s"
values = [league.id]
results = run_sql(sql, values)
game_no = 1
for result in results:
game = Game(result['team_1'], result['team_2'], league,
result['round_no'], game_no)
fixtures.append(game)
game_no += 1
teams = []
sql = "SELECT teams.* FROM teams INNER JOIN leagues ON leagues.id = teams.league_id WHERE leagues.id = %s"
values = [league.id]
results = run_sql(sql, values)
for result in results:
team = Team(league, result['name'], result['games_played'],
result['wins'], result['draws'], result['losses'],
result['goals_for'], result['goals_against'],
result['goal_difference'], result['points'], result['id'])
teams.append(team)
games = []
for fixture in fixtures:
team_1 = fixture.team_1
team_2 = fixture.team_2
game = Game(teams[team_1 - 1], teams[team_2 - 1], league,
fixture.round_no, fixture.game_no)
games.append(game)
return games
def parse(self, response):
teams = []
for team in response['hits']['hits']:
first_tpid = int(team['_id'])
team = team['_source']
raw_website = team.get('team_web_url', None)
website = urlparse.urlparse(
raw_website, 'http').geturl() if raw_website else None
teams.append(
Team(
id="frc{}".format(team['team_number_yearly']),
team_number=team['team_number_yearly'],
name=team.get('team_name', None),
nickname=team.get('team_nickname', None),
# city=None,
# state_prov=None, # team_stateprov isn't in the same format as the FRC API (e.g. 'CA' instead of 'California'). Don't save to avoid unnecessary cache clearing.
# country=None,
postalcode=team.get('team_postalcode', None),
website=website,
rookie_year=team.get('team_rookieyear', None),
first_tpid=first_tpid,
first_tpid_year=self.year,
motto=team.get('team_motto', None),
))
return teams
def create_client(user, params):
name = params.get("name", "")
if not name or len(name) > 30:
return {"error_code": 20251, "msg": "name invalid"}
#team = Team.select().where(Team.user == user, Team.name == name).first()
team = Team.select().where(Team.user == user).first()
if team:
return {"error_code": 20252, "msg": "team is exists and must one"}
team_id = GUID.guid()
team = Team()
team.id = team_id
team.user = user
team.name = name
team.status = "normal"
team.team_type = 'client'
team.logo = widget.logo()
team.save(force_insert=True)
user.to_req = True
user.identify = "c%s" % team.id
user.save()
team_profile = TeamProfile()
team_profile.team = team
team_profile.save()
#Member.create(user=user, team=team, mtype='owner')
return {"error_code": 0, "msg": "ok"}
def setUp(self):
app = webapp2.WSGIApplication([webapp2.Route(r'/<team_key:>', ApiTeamHistoryDistrictsController, methods=['GET'])], debug=True)
self.testapp = webtest.TestApp(app)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_memcache_stub()
self.testbed.init_taskqueue_stub(root_path=".")
self.team = Team(
id="frc1124",
name="UberBots",
team_number=1124,
nickname="UberBots",
)
self.district_team = DistrictTeam(
id="2015ne_frc1124",
team=self.team.key,
year=2015,
district=3
)
self.team.put()
self.district_team.put()
def select(id):
sql = "SELECT * FROM teams WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
team = Team(result["name"], result['coach'], result['wins'],
result['losses'], result["id"])
return team
def setUp(self):
self.policy = datastore_stub_util.PseudoRandomHRConsistencyPolicy(
probability=1)
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub(consistency_policy=self.policy)
self.testbed.init_memcache_stub()
self.testbed.init_user_stub()
self.testbed.init_urlfetch_stub()
self.testbed.init_taskqueue_stub(_all_queues_valid=True)
ndb.get_context().clear_cache(
) # Prevent data from leaking between tests
app = webapp2.WSGIApplication([
RedirectRoute(r'/mod/redeem',
TeamAdminRedeem,
'team-admin',
strict_slash=True),
])
self.testapp = webtest.TestApp(app)
self.team = Team(
id="frc1124",
name="Team",
team_number=1124,
)
self.team.put()
self.now = datetime.datetime.now()
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
self.testbed.init_memcache_stub()
event = Event(
id="2011ct",
end_date=datetime.datetime(2011, 4, 2, 0, 0),
event_short="ct",
event_type_enum=EventType.REGIONAL,
first_eid="5561",
name="Northeast Utilities FIRST Connecticut Regional",
start_date=datetime.datetime(2011, 3, 31, 0, 0),
year=2011,
venue_address="Connecticut Convention Center\r\n100 Columbus Blvd\r\nHartford, CT 06103\r\nUSA",
website="http://www.ctfirst.org/ctr"
)
event.put()
team = Team(
id="frc177",
team_number=177,
website="http://www.bobcatrobotics.org"
)
team.put()
event_team = EventTeam(
id="%s_%s" % (event.key.id(), team.key.id()),
event=event.key,
team=team.key,
year=None)
event_team.put()
