Ejemplo n.º 1
0
    def test_fetch_by_id(self):
        expected_count = 1
        generated_data = self._prepopulate_datastore(year=self.year, week=self.week)
        test_data = generated_data[0]

        spread = Spread()
        data = spread.fetch_by_id(year=self.year, week=self.week, game_id=test_data['game_id'])
        self.assertEqual(data, test_data)
Ejemplo n.º 2
0
 def _delete(self):
     query = Spread.all()
     query.filter('week =', str(12))
     result = query.fetch(1000)
     
     for item in result:
         key = item.key()
         matchup = Spread.get(key)
         matchup.delete()
Ejemplo n.º 3
0
    def get(self, year, week, game):
        year = int(year)
        week = int(week)
        game = int(game)

        spread = Spread()
        result = spread.fetch_by_id(year=year, week=week, game_id=game)

        self._send_response(result)
Ejemplo n.º 4
0
    def test_update_model(self):
        generated_data = self._generate_data(year=self.year, week=self.week, count=1)
        test_data = generated_data[0]

        model = SpreadModel(**test_data)
        test_data['game_line'] += randint(1, 100)

        spread = Spread()
        result = spread._update_model(model, test_data)
        self.assertEqual(result.to_dict(), test_data)
Ejemplo n.º 5
0
    def test_find_existing_with_all_data(self):
        test_data = self._prepopulate_datastore(year=self.year, week=self.week, count=self.expected_count)

        spread = Spread()
        key = spread._generate_key(year=self.year, week=self.week)
        data = spread._find_existing_entries(key, test_data)
        self.assertEqual(len(data), self.expected_count)

        for game in test_data:
            self.assertTrue(game['game_id'] in data)
Ejemplo n.º 6
0
    def put(self, year, week, game):
        year = int(year)
        week = int(week)
        game = int(game)
        spread_data = json.loads(self.request.POST['spread'])

        spread = Spread()
        result = spread.save_by_id(year=year, week=week, game_id=game, data=spread_data)

        self._send_response()
Ejemplo n.º 7
0
    def test_fetch_spread(self):
        expected_count = 1
        test_data = self._prepopulate_datastore(year=self.year, week=self.week, count=expected_count)

        spread = Spread()
        data = spread.fetch(year=self.year, week=self.week)
        self.assertEqual(len(data), expected_count)

        for index, game in enumerate(data):
            expected_game = test_data[index]
            self.assertEqual(game, expected_game)
Ejemplo n.º 8
0
    def test_save_by_id(self):
        generated_data = self._generate_data(year=self.year, week=self.week)
        test_data = generated_data[0]
        game_id = test_data['game_id']

        spread = Spread()
        count = spread.save_by_id(year=self.year, week=self.week, game_id=game_id, data=test_data)
        self.assertEqual(count, 1)

        # Check datastore
        data = SpreadModel.query(SpreadModel.game_id == game_id).fetch(1)
        self.assertEqual(data[0].to_dict(), test_data)
Ejemplo n.º 9
0
    def get(self, year, week):
        year = int(year)
        week = int(week)

        spread = Spread()
        spread_data = spread.fetch(year=year, week=week)

        result = {
            'spread': spread_data
        }

        self._send_response(result)
Ejemplo n.º 10
0
class TestSpreadAbstract(unittest.TestCase):
    def setUp(self):
        self.spread = Spread()
        self.week = 1

    def test_initial(self):
        self.assertIsNone(
            self.spread.next,
            "Testing initial state")

    def test_fetch_is_not_implemented(self):
        with self.assertRaises(NotImplementedError):
            self.spread.fetch(self.week),

    def test_protected_fetch_is_unimplemented(self):
        with self.assertRaises(NotImplementedError):
            self.spread._fetch_spread(self.week)

    def test_save_is_not_implemented(self):
        data = {}

        with self.assertRaises(NotImplementedError):
            self.spread.save(self.week, data),


    def test_protected_save_is_unimplemented(self):
        data = {}

        with self.assertRaises(NotImplementedError):
            self.spread._save_spread(self.week, data)
Ejemplo n.º 11
0
    def put(self, year, week):
        """
        WARNING! Use of this endpoint will create odd side-effects
        This endpoint does not acknowledge the 'game_id' property of spread data
        """
        year = int(year)
        week = int(week)
        param = self.request.POST['spread']     # webapp2 treats POST body the same for PUT
        spread_data = json.loads(param)

        spread = Spread()
        result = spread.save(year=year, week=week, data=spread_data)

        self.response.set_status(201)
        self._send_response()
Ejemplo n.º 12
0
    def test_save_by_id_same(self):
        generated_data = self._generate_data(year=self.year, week=self.week)
        test_data = generated_data[0]
        game_id = test_data['game_id']

        spread = Spread()
        spread.save_by_id(year=self.year, week=self.week, game_id=game_id, data=test_data)

        test_data['game_line'] += randint(7, 14)
        spread.save_by_id(year=self.year, week=self.week, game_id=game_id, data=test_data)

        # Check datastore
        data = SpreadModel.query(SpreadModel.game_id == game_id).fetch(2)
        self.assertEqual(len(data), 1)
        self.assertEqual(data[0].to_dict(), test_data)
Ejemplo n.º 13
0
    def test_save_multiple_spread(self):
        expected_count = randint(2, 16)
        test_data = self._generate_data(year=self.year, week=self.week, count=expected_count)

        spread = Spread()
        count = spread.save(year=self.year, week=self.week, data=test_data)
        self.assertEqual(count, expected_count)

        # Check datastore
        ancestor_key = spread._generate_key(year=self.year, week=self.week)
        data = SpreadModel().query(ancestor=ancestor_key).order(SpreadModel.game_id).fetch(expected_count+1)
        self.assertEqual(len(data), expected_count)

        for index in range(expected_count):
            expected_game = test_data[index]
            game = data[index].to_dict()
            self.assertEqual(game, expected_game)
Ejemplo n.º 14
0
    def test_find_existing_with_some_data(self):
        test_data = self._generate_data(year=self.year, week=self.week, count=self.expected_count)
        spread = Spread()
        key = spread._generate_key(year=self.year, week=self.week)

        # Preload half
        preload = []
        preload_count = self.expected_count/2
        for i in range(preload_count):
            spread_data = {'parent': key}
            spread_data.update(test_data[i])
            preload.append(SpreadModel(**spread_data))
        ndb.put_multi(preload)

        data = spread._find_existing_entries(key, test_data)
        self.assertEqual(len(data), preload_count)

        for game in preload:
            self.assertTrue(game.game_id in data)
Ejemplo n.º 15
0
    def test_save_same(self):
        expected_count = 1
        generated_data = self._generate_data(year=self.year, week=self.week, count=expected_count)

        spread = Spread()
        count = spread.save(year=self.year, week=self.week, data=generated_data)

        generated_data[0]['game_line'] += 13
        count = spread.save(year=self.year, week=self.week, data=generated_data)

        # Check datastore
        ancestor_key = spread._generate_key(year=self.year, week=self.week)
        data = SpreadModel().query(ancestor=ancestor_key).fetch(expected_count+1)
        self.assertEqual(len(data), expected_count)

        for index in range(expected_count):
            expected_game = generated_data[index]
            game = data[index].to_dict()
            self.assertEqual(game, expected_game)
Ejemplo n.º 16
0
    def _query_database(self, week):
        query = {}
        result = {}
        
        query = Spread.all()
        query.filter('week =', week)
        query.order('person')

        result = query.fetch(constants.QUERY_LIMIT)
        return result
Ejemplo n.º 17
0
    def _save_spread(self, week, spread):
        query = Spread.all()
        result = None
        item = None

        query.filter('week =', week)
        result = query.fetch(constants.QUERY_LIMIT)
        
        if len(result) == 0:
            #completely new save
            for person in spread:
                for line in spread[person]:
                    item = Spread(
                        year = constants.YEAR,
                        week = week,
                        person = person,
                        team_name = line[constants.SPREAD_TEAM_NAME],
                        over_under = line[constants.SPREAD_OVER_UNDER],
                        total_score = int(line[constants.SPREAD_TOTAL_SCORE])
                        )

                    item.put()
Ejemplo n.º 18
0
 def setUp(self):
     self.spread = Spread()
     self.week = 1