class ProfileTest(unittest.TestCase):
    """test interactactions between profiles"""
    
    def setUp(self):
        """override one in unittest.TestCase"""
        # bruce
        doc = FileDocument(PROFILE_BRUCE, PROFILE_DIRECTORY)
        self.assert_(doc.load())
        self.bruce_doc = CacheDocument(PROFILE_BRUCE, PROFILE_DIRECTORY)
        self.bruce_doc.import_document(doc)
        # demi
        self.demi_doc = FileDocument(PROFILE_DEMI, PROFILE_DIRECTORY)
        self.assert_(self.demi_doc.load())

    def test_bruce(self):
        """import bruce data"""
        self.assertEquals("Bruce", self.bruce_doc.get_firstname())
        self.assertEquals("Willis", self.bruce_doc.get_lastname())
        self.assertEquals("*****@*****.**", self.bruce_doc.get_email())
        self.assertEquals({'City': u'', 'Country': u'',
                           'Favourite Book': u'', 'music': u'jazz',
                           'Favourite Movie': u'', 'Sport': u'', 'Studies': u'',
                           'film': u'Die Hard'},
                          self.bruce_doc.get_custom_attributes())

    def test_peer_status(self):
        self.assertEquals(self.demi_doc.has_peer(self.bruce_doc.pseudo), False)
        self.demi_doc.fill_data((self.bruce_doc.pseudo, self.bruce_doc))
        self.assertEquals(self.demi_doc.has_peer(self.bruce_doc.pseudo), True)
        self.demi_doc.make_friend(self.bruce_doc.pseudo)
        self.assertEquals(self.demi_doc.has_peer(self.bruce_doc.pseudo), True)
        self.demi_doc.unmark_peer(self.bruce_doc.pseudo)
        self.assertEquals(self.demi_doc.has_peer(self.bruce_doc.pseudo), False)
class ProfileTest(unittest.TestCase):
    """test interactactions between profiles"""
    
    def setUp(self):
        """override one in unittest.TestCase"""
        # bruce
        doc = FileDocument()
        self.assert_(doc.load(TEST_BRUCE))
        self.bruce_doc = CacheDocument()
        self.bruce_doc.import_document(doc)
        # demi
        self.demi_doc = FileDocument()
        self.assert_(self.demi_doc.load(TEST_DEMI))

    def test_bruce(self):
        """import bruce data"""
        self.assertEquals("Bruce", self.bruce_doc.get_firstname())
        self.assertEquals("Willis", self.bruce_doc.get_lastname())
        self.assertEquals("john", self.bruce_doc.get_pseudo())
        self.assertEquals("*****@*****.**", self.bruce_doc.get_email())
        self.assertEquals("01/06/1947", self.bruce_doc.get_birthday())
        self.assertEquals("English", self.bruce_doc.get_language())
        self.assertEquals("Hill", self.bruce_doc.get_address())
        self.assertEquals("920", self.bruce_doc.get_postcode())
        self.assertEquals("Los Angeles", self.bruce_doc.get_city())
        self.assertEquals("US", self.bruce_doc.get_country())
        self.assertEquals("Lots of movies, quite famous, doesn't look much but very effective",
                          self.bruce_doc.get_description())
        self.assertEquals([u'cinema', u'theatre', u'cop', u'action'], self.bruce_doc.get_hobbies())
        self.assertEquals({'music': u'jazz', 'film': u'Die Hard'},
                          self.bruce_doc.get_custom_attributes())
class HtmlTest(unittest.TestCase):
    """test that all fields are correctly validated"""

    def setUp(self):
        """override one in unittest.TestCase"""
        self.document = CacheDocument()
        self.view = HtmlView(self.document)

    def assert_template(self):
        """diff result from view with expeceted template"""
        self.view.import_document(self.document)
        result = difflib.ndiff(
            [line.strip() for line in self.print_template().splitlines()],
            [line.strip() for line in self.view.get_view(True).splitlines()],
            charjunk=lambda x: x in [" ", "\t"],
        )
        result = list(result)
        for index, line in enumerate(result):
            if not line.startswith("  "):
                print self.view.get_view()
                print "*************"
                print "\n".join(result[index - 2 : index + 10])
            self.assert_(line.startswith("  "))

    def print_template(self):
        """fill template with values"""
        return TEMPLATE % (
            self.document.get_photo(),
            self.document.get_pseudo(),
            self.document.get_title(),
            self.document.get_firstname(),
            self.document.get_lastname(),
            self.document.get_email(),
            self.document.get_birthday(),
            self.document.get_language(),
            self.document.get_address(),
            self.document.get_postcode(),
            self.document.get_city(),
            self.document.get_country(),
            self.document.get_description(),
            self.print_hobbies(),
            self.print_custom(),
            self.print_files(),
            self.print_peers(),
        )

    def print_hobbies(self):
        html = [" <span>%s</span> |" % item for item in self.document.get_hobbies()] or ""
        return "".join(html)

    def print_custom(self):
        html = [
            "<div><b>%s</b>: <span>%s</span></div>" % (key, value)
            for key, value in self.document.get_custom_attributes().iteritems()
        ]
        return "".join(html)

    def print_files(self):
        html = []
        repos = self.document.get_repositories()
        repos.sort()
        for repo in repos:
            html.append(
                """
    <dt>%s</dt>
    <dd>%d shared files</dd>
"""
                % (repo, len(self.document.get_shared(repo)))
            )
        # concatenate all description of directories & return result
        return "".join(html)

    def print_peers(self):
        html = []
        peers = self.document.get_peers()
        keys = peers.keys()
        keys.sort()
        for key in keys:
            peers_desc = peers[key]
            doc = peers_desc.document
            html.append(
                """<tr>
      <td>%s</td>
      <td>%s</td>
      <td>%s</td>
    </tr>"""
                % (peers_desc.state, doc and doc.get_pseudo() or "--", peers_desc.peer_id)
            )
        return "".join(html)

    # PERSONAL TAB
    def test_personal(self):
        """personal info"""
        self.document.set_title(u"Mr")
        self.document.set_firstname(u"Bruce")
        self.document.set_lastname(u"Willis")
        self.document.set_pseudo(u"john")
        self.document.set_photo(u"/home/emb/svn/solipsis/trunk/main/solipsis/services/profile/images/profile_male.gif")
        self.document.set_email(u"*****@*****.**")
        self.document.set_birthday(u"1/6/1947")
        self.document.set_language(u"English")
        self.document.set_address(u"Hill")
        self.document.set_postcode(u"920")
        self.document.set_city(u"Los Angeles")
        self.document.set_country(u"US")
        self.document.set_description(u"Lots of movies, quite famous, doesn't look much but very effective")
        self.assert_template()

    # CUSTOM TAB
    def test_hobbies(self):
        self.document.set_hobbies([u"cinema", u"theatre", u"cop", u"action"])
        self.assert_template()

    def test_custom(self):
        self.document.add_custom_attributes([u"zic", u"jazz"])
        self.document.add_custom_attributes([u"cinema", u"Die Hard"])
        self.assert_template()

    # FILE TAB
    def test_files(self):
        self.document.add_repository(abspath(u"."))
        self.document.expand_dir(abspath(u"data"))
        self.document.share_files((abspath(u"data"), ["routage"], True))
        self.document.share_file((abspath(u"data/emptydir"), True))
        self.assert_template()

    # OTHERS TAB
    def test_ordered_peer(self):
        self.document.add_peer(u"nico")
        self.document.make_friend(u"emb")
        self.document.make_friend(u"star")
        self.document.make_friend(u"albert")
        self.assert_template()

    def test_adding_peer(self):
        self.document.add_peer(u"nico")
        self.assert_template()

    def test_filling_data(self):
        self.document.fill_data((u"emb", FileDocument()))
        self.assert_template()

    def test_peers_status(self):
        self.document.blacklist_peer(u"nico")
        self.assert_template()