import unittest
import StringIO
from copy import deepcopy

import whoisi_cache

json = whoisi_cache.json

class FakeWhoisiServer(object):
    def __init__(self, people):
        self._people = people

    def get_max_person_id(self, app):
        return {'person_id': len(self._people)}

    def _validate_index(self, index):
        if index <= 0 or index > self.get_max_person_id(None):
            raise ValueError('index %d out of range' % indexe)

    def get_people(self, app, first, last):
        self._validate_index(first)
        self._validate_index(last)
        result = {}
        for index in range(first-1, last):
            if self._people[index]:
                result[str(index+1)] = deepcopy(self._people[index])
        return {'people': result}

    def get_person(self, app, person):
        self._validate_index(person)
        return {'person': deepcopy(self._people[person-1])}

class WhoisiServerTests(unittest.TestCase):
    def setUp(self):
        unittest.TestCase.setUp(self)
        self.urls = {}
        self.server = whoisi_cache.WhoisiServer(url="http://foo/",
                                                urlopen=self.fake_open)

    def fake_open(self, url):
        return StringIO.StringIO(json.dumps(self.urls[url]))

    def testGetMaxPersonIDWorks(self):
        self.urls = {
            'http://foo/api/getMaxPersonID?app=f': ['zap']
            }
        self.assertEqual(self.server.get_max_person_id(app="f"),
                         ['zap'])

    def testGetPeopleWorks(self):
        self.urls = {
            'http://foo/api/getPeople?app=f&first=1&last=2': ['bop']
            }
        self.assertEqual(self.server.get_people(app="f", first=1,
                                                last=2),
                         ['bop'])

    def testGetPersonWorks(self):
        self.urls = {
            'http://foo/api/getPerson?app=f&person=1': ['blap']
            }
        self.assertEqual(self.server.get_person(app="f", person=1),
                         ['blap'])

class WhoisiCacheTests(unittest.TestCase):
    def testRefreshPeopleWorks(self):
        people = [{'name': "bobbo"}, {'name': 'gobbo'}]
        server = FakeWhoisiServer(people)
        cache_storage = []
        cache = whoisi_cache.WhoisiCache(server=server,
                                         storage=cache_storage)
        cache.update()
        self.assertEqual(people, cache_storage)

        people[0]['name'] = "bleh"
        people[1]['name'] = "hmm"

        self.assertNotEqual(people[0], cache_storage[0])
        self.assertNotEqual(people[1], cache_storage[1])

        cache.refresh_people([0])
        self.assertEqual(people[0], cache_storage[0])
        self.assertNotEqual(people[1], cache_storage[1])

    def testUpdateWorksWithEmptyPeople(self):
        people = ["a", None, "c"]
        server = FakeWhoisiServer(people)
        cache_storage = []
        cache = whoisi_cache.WhoisiCache(server=server,
                                         storage=cache_storage,
                                         batch_size=2)
        cache.update()
        self.assertNotEqual(people, cache_storage)
        self.assertEqual(people[0], cache_storage[0])
        self.assertEqual(whoisi_cache.EMPTY_PERSON, cache_storage[1])
        self.assertEqual(people[2], cache_storage[2])
        
    def testUpdateWorks(self):
        people = []
        server = FakeWhoisiServer(people)
        cache_storage = []
        cache = whoisi_cache.WhoisiCache(server=server,
                                         storage=cache_storage,
                                         batch_size=2)
        cache.update()
        self.assertEqual(people, cache_storage)

        people.extend(["a", "b", "c"])

        self.assertNotEqual(people, cache_storage)
        cache.update()
        self.assertEqual(people, cache_storage)

        people.extend(["d"])

        self.assertNotEqual(people, cache_storage)
        cache.update()
        self.assertEqual(people, cache_storage)