Rearranged some methods + tests

challonge/tournament.py

@@ -556,8 +556,8 @@ async def get_participant(self, p_id: int, force_update=False) -> Participant:
         """
         found_p = self._find_participant(p_id)
         if force_update or found_p is None:
-            res = await self.connection('GET', 'tournaments/{}/participants/{}'.format(self._id, p_id))
-            found_p._refresh_from_json(res)
+            await self.get_participants()
+        found_p = self._find_participant(p_id)
         return found_p
 
     async def get_participants(self, force_update=False) -> list:
@@ -576,8 +576,7 @@ async def get_participants(self, force_update=False) -> list:
 
         """
         if force_update or self.participants is None:
-            res = await self.connection('GET',
-                                        'tournaments/{}/participants'.format(self._id))
+            res = await self.connection('GET', 'tournaments/{}/participants'.format(self._id))
             self._refresh_participants_from_json(res)
         return self.participants or []
 
@@ -598,7 +597,7 @@ async def search_participant(self, name, force_update=False):
 
         """
         if force_update or self.participants is None:
-            self.get_participants()
+            await self.get_participants()
         if self.participants is not None:
             for p in self.participants:
                 if p.name == name:

challonge/user.py

@@ -21,6 +21,17 @@ def _add_tournament(self, t: Tournament):
             else:
                 self.tournaments.append(t)
 
+    def _refresh_tournament_from_json(self, tournament_data):
+        if self.tournaments is None:
+            self.tournaments = [self._create_tournament(tournament_data)]
+        else:
+            for t in self.tournaments:
+                if tournament_data['tournament']['id'] == t._id:
+                    t._refresh_from_json(tournament_data)
+                    break
+            else:
+                self.tournaments.append(self._create_tournament(tournament_data))
+
     def _create_tournament(self, json_def) -> Tournament:
         return Tournament(self.connection, json_def)
 
@@ -61,8 +72,9 @@ async def get_tournament(self, t_id: int, force_update=False) -> Tournament:
         found_t = self._find_tournament(t_id)
         if force_update or found_t is None:
             res = await self.connection('GET', 'tournaments/{}'.format(t_id))
-            found_t = self._create_tournament(res)
-            self._add_tournament(found_t)
+            self._refresh_tournament_from_json(res)
+            found_t = self._find_tournament(t_id)
+
         return found_t
 
     async def get_tournaments(self, force_update=False) -> list:
@@ -86,10 +98,13 @@ async def get_tournaments(self, force_update=False) -> list:
                 'include_matches': 1 if CHALLONGE_AUTO_GET_MATCHES else 0
             }
             res = await self.connection('GET', 'tournaments', **params)
-            self.tournaments = [self._create_tournament(t) for t in res]
-        if self.tournaments is not None:
-            return self.tournaments
-        return []
+            if len(res) == 0:
+                self.tournaments = []
+            else:
+                for t_data in res:
+                    self._refresh_tournament_from_json(t_data)
+
+        return self.tournaments
 
     async def create_tournament(self, name: str, url: str, tournament_type=TournamentType.single_elimination, **params) -> Tournament:
         """ creates a simple tournament with basic options
@@ -115,9 +130,8 @@ async def create_tournament(self, name: str, url: str, tournament_type=Tournamen
             'tournament_type': tournament_type.value,
         })
         res = await self.connection('POST', 'tournaments', 'tournament', **params)
-        new_t = self._create_tournament(res)
-        self._add_tournament(new_t)
-        return new_t
+        self._refresh_tournament_from_json(res)
+        return self._find_tournament(res['tournament']['id'])
 
     async def destroy_tournament(self, t: Tournament):
         """ completely removes a tournament from Challonge

tests.py

@@ -70,8 +70,23 @@ def test_a_init(self):
     @async_test
     def test_b_get_tournaments(self):
         new_user = yield from challonge.get_user(username, api_key)
-        t = yield from new_user.get_tournaments()
-        self.assertIsInstance(t, list)
+        ts = yield from new_user.get_tournaments()
+        self.assertIsInstance(ts, list)
+
+        random_name = get_random_name()
+        t1 = yield from new_user.create_tournament(random_name, random_name)
+
+        t2 = yield from new_user.get_tournament(t1.id)
+        self.assertEqual(t1, t2)
+
+        t3 = yield from new_user.get_tournament(t1.id, force_update=True)
+        self.assertEqual(t1, t3)
+
+        fake_id = 0
+        t4 = yield from new_user.get_tournament(fake_id)
+        self.assertEqual(t4, None)
+
+        yield from new_user.destroy_tournament(t1)
 
 
 # @unittest.skip('')
@@ -84,14 +99,11 @@ def setUp(self):
     @async_test
     def test_a_create_destroy(self):
         random_name = get_random_name()
-        t = yield from self.user.create_tournament(random_name, random_name)
-        self.assertEqual(t.name, random_name)
-
-        t2 = yield from self.user.get_tournament(t.id)
-        self.assertEqual(t.id, t2.id)
+        t1 = yield from self.user.create_tournament(random_name, random_name)
+        self.assertEqual(t1.name, random_name)
 
         t_count = len(self.user.tournaments)
-        yield from self.user.destroy_tournament(t)
+        yield from self.user.destroy_tournament(t1)
         self.assertEqual(len(self.user.tournaments), t_count-1)
 
     # @unittest.skip('')
@@ -161,6 +173,9 @@ def test_b_add_participants(self):
         self.assertEqual(p1.id, p1_1.id)
         self.assertEqual(len(t.participants), 2)
 
+        p1_2 = yield from t.get_participant(0)
+        self.assertEqual(p1_2, None)
+
         ps = yield from t.get_participants(force_update=True)
         self.assertEqual(len(t.participants), 2)
 
@@ -459,8 +474,13 @@ def test_b_report_winner(self):
         random_name = get_random_name()
         t = yield from self.user.create_tournament(random_name, random_name)
         yield from t.add_participants('p1', 'p2', 'p3', 'p4')
+
         p1 = yield from t.search_participant('p1')
         self.assertEqual(p1.name, 'p1')
+
+        p_fake = yield from t.search_participant('fake')
+        self.assertEqual(p_fake, None)
+
         yield from t.start()
         m = yield from t.get_matches()
         yield from m[0].report_winner(p1, '1-0')
@@ -497,7 +517,7 @@ def test_a_url(self):
         yield from t.allow_attachments()
         yield from t.add_participants('p1', 'p2', 'p3', 'p4')
         yield from t.start()
-        m = yield from t.get_matches()
+        m = yield from t.get_matches(force_update=True)
 
         a1 = yield from m[0].attach_url('https://github.com/fp12/achallonge')
         self.assertEqual(a1.url, 'https://github.com/fp12/achallonge')