コード例 #1
0
 def setUp(self):
     """override one in unittest.TestCase"""
     self.documents = [CacheDocument(), FileDocument()]
     for document in self.documents:
         document.add_repository(REPO)
     self.abstract_doc = AbstractDocument()
     self.abstract_doc.add_repository(REPO)
コード例 #2
0
 def setUp(self):
     """override one in unittest.TestCase"""
     self.documents = [CacheDocument(PROFILE_TEST, PROFILE_DIRECTORY),
                       FileDocument(PROFILE_TEST, PROFILE_DIRECTORY)]
     for document in self.documents:
         document.add_file(REPO)
     self.abstract_doc = AbstractDocument(PROFILE_TEST, PROFILE_DIRECTORY)
     self.abstract_doc.add_file(REPO)
コード例 #3
0
 def setUp(self):
     """override one in unittest.TestCase"""
     write_test_profile()
     self.documents = [CacheDocument(), FileDocument()]
     for document in self.documents:
         document.add_repository(TEST_DIR)
     self.abstract_doc = AbstractDocument()
     self.abstract_doc.add_repository(TEST_DIR)
コード例 #4
0
class DocumentTest(unittest.TestCase):
    """test that all fields are correctly validated"""

    def setUp(self):
        """override one in unittest.TestCase"""
        self.documents = [CacheDocument(), FileDocument()]
        for document in self.documents:
            document.add_repository(REPO)
        self.abstract_doc = AbstractDocument()
        self.abstract_doc.add_repository(REPO)

    def test_config_parser(self):
        writer = CustomConfigParser()
        writer.add_section('TEST')
        writer.set('TEST', "Windows:path", "not a valid linux:path!")
        writer.write(open("generated/config.test", "w"))
        # standard reader
        reader = ConfigParser()
        reader.readfp(open("generated/config.test"))
        self.assert_(reader.has_section('TEST'))
        self.assert_(reader.has_option('TEST', "Windows"))
        self.assertEquals(reader.get('TEST', "Windows"), "path = not a valid linux:path!")
        # custom reader
        reader = CustomConfigParser()
        reader.readfp(open("generated/config.test"))
        self.assert_(reader.has_section('TEST'))
        self.assert_(reader.has_option('TEST', "Windows:path"))
        self.assertEquals(reader.get('TEST', "Windows:path"), "not a valid linux:path!")

    # PERSONAL TAB
    def test_title(self):
        """title as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_title)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_title, "Mr")
            self.assertRaises(TypeError, document.set_title, [u"Mr", ])
            document.set_title(u"Mr")
        
    def test_firstname(self):
        """firstname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_firstname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_firstname, "manu")
            self.assertRaises(TypeError, document.set_firstname, [u"manu", ])
            document.set_firstname(u"manu")
        
    def test_lastname(self):
        """lastname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_lastname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_lastname, "breton")
            self.assertRaises(TypeError, document.set_lastname, [u"breton", ])
            document.set_lastname(u"breton")
    
    def test_pseudo(self):
        """pseudo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_pseudo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_pseudo, "emb")
            self.assertRaises(TypeError, document.set_pseudo, [u"manu", u"emb"])
            document.set_pseudo(u"emb")
    
    def test_photo(self):
        """photo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_photo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_photo, "./dummy/dummy.jpg")
            document.set_photo(unicode(unittest.__file__, ENCODING))
        
    def test_email(self):
        """email as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_email)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_email, "*****@*****.**")
            self.assertRaises(TypeError, document.set_email, [u"manu@ft", ])
            document.set_email(u"*****@*****.**")
        
    def test_birthday(self):
        """birthday as datetime"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_birthday)
        for document in self.documents:
            document.set_birthday(u"12/01/2005")
            birthday = document.get_birthday()
            document.set_birthday("12 jan 2005")
            self.assertEquals(document.get_birthday(), birthday)
            document.set_birthday("2005/01/12")
            self.assertEquals(document.get_birthday(), birthday)
            document.set_birthday("12-01-2005")
            self.assertEquals(document.get_birthday(), birthday)
            document.set_birthday("12012005")
            self.assertEquals(document.get_birthday(), birthday)
            document.set_birthday("12/01")
            self.assertEquals(document.get_birthday(), birthday)
            
    def test_language(self):
        """language as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_language)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_language, "fr")
            self.assertRaises(TypeError, document.set_language, [u"fr", u"sp"])
            document.set_language(u"fr")
        
    def test_address(self):
        """address as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_address)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_address, "12 rue V Hugo")
            self.assertRaises(TypeError, document.set_address, [u"12",
                                                                u"rue V Hugo"])
            document.set_address(u"12 rue V Hugo")
        
    def test_postcode(self):
        """postcode as int convertable"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_postcode)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_postcode, "34.000")
            self.assertRaises(TypeError, document.set_postcode, "34 000")
            self.assertRaises(TypeError, document.set_postcode, "Herault")
            self.assertRaises(TypeError, document.set_birthday, ["34", ])
            document.set_postcode(u"34000")
            document.set_postcode("34000")
        
    def test_city(self):
        """city as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_city)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_city, "Paris")
            self.assertRaises(TypeError, document.set_city, [u"Paris", ])
            document.set_city(u"Paris")
        
    def test_country(self):
        """country as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_country)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_country, "France")
            self.assertRaises(TypeError, document.set_country, [u"France", ])
            document.set_country(u"France")
        
    def test_description(self):
        """description as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_description)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_description, "anything")
            self.assertRaises(TypeError, document.set_description, [u"anything", ])
            document.set_description(u"anything")
        
    def test_download_repo(self):
        """download_repo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_download_repo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_download_repo, "anything")
            self.assertRaises(TypeError, document.set_download_repo, [u"anything", ])
            document.set_description(u"anything")
        
    # CUSTOM TAB
    def test_hobbies(self):
        """hobbies as unicode (multiple lines)"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_hobbies)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_hobbies,
                              "blabla\nbla bla bla\n")
            self.assertRaises(TypeError, document.set_hobbies,
                              u"blabla\nbla bla bla\n")
            document.set_hobbies([u"blabla", u"bla bla bla", u""])
        
    def test_custom_attributes(self):
        """custom_attributes as pair of key/unicode-value"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_custom_attributes)
        for document in self.documents:
            self.assertRaises(TypeError, document.add_custom_attributes,
                              "homepage: manu.com")
            self.assertRaises(TypeError, document.add_custom_attributes,
                              ("homepage", "manu.com", "yo"))
            self.assertRaises(TypeError, document.add_custom_attributes,
                              ("homepage", "manu.com"))
            document.add_custom_attributes((u"homepage", u"manu.com"))
            self.assertRaises(TypeError, document.remove_custom_attributes,
                              "homepage")
            document.remove_custom_attributes(u"homepage")
        
    # FILE TAB
    def test_reset_files(self):
        """reset files"""
        for document in self.documents:
            document.add((abspath(u"data")))
            document.share_file((abspath(u"data"), True))
            self.assertEquals(document.get_container(abspath(u"data"))._shared, True)
            document.reset_files()
            self.assertEquals(document.get_files(), {})
        
    def test_repository(self):
        """repository valid path"""
        for document in self.documents:
            self.assertRaises(TypeError, document.add, abspath("data/dummy"))
            document.add(abspath(u"data"))
            document.remove(abspath(u"data"))
        
    def test_share_dir(self):
        """share dir giving unicode name"""
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.share_dirs, "data, True")
            self.assertRaises(TypeError, document.share_dirs, ("data", ))
            self.assertRaises(TypeError, document.share_dirs, ("data", True))
            self.assertRaises(TypeError, document.share_dirs, (abspath(u"data"), True))
            document.share_dirs(([abspath(u"data")], True))
            document.share_dirs([[abspath(u"data")], True])
        
    def test_share_files(self):
        """share files giving root & unicode names"""
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.share_files,
                              "data, ['.path', 'routage'], True")
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage'], True"))
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage']", "True"))
            self.assertRaises(TypeError, document.share_files,
                              (u"data", "['.path', 'routage']", True))
            self.assertRaises(TypeError, document.share_files,
                              ("data", ['.path', 'routage'], True))
            document.share_files((abspath(u"data"), ['.path', 'routage'], True))
            document.share_files([abspath(u"data"), ['.path', 'routage'], True])
        
    def test_tag_file(self):
        """tag files giving root & unicode names"""
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.tag_files,
                              "data, ['.path', 'routage'], tag desc")
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage'], tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage']", "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", ['.path', 'routage'], "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              (u"data", "['.path', 'routage']", "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              (u"data", ['.path', 'routage'], "tag desc"))
            document.tag_files((abspath(u"data"), ['.path', 'routage'], u"tag desc"))
            document.tag_files([abspath(u"data"), ['.path', 'routage'], u"tag desc"])
        
    def test_add_file(self):
        """expand dir giving unicode name"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_files)
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.expand_dir, "data/dummy")
            self.assertRaises(TypeError, document.expand_dir, "data")
            document.expand_dir((abspath(u"data")))

    def test_get_container(self):
        """retreive correct contaier"""
        for document in self.documents:
            document.tag_files((abspath(u"data/profiles"),
                               ["bruce.prf", ".svn"], u"first"))
            document.share_files((abspath(u"data/profiles"),
                                  ["bruce.prf", "demi.prf"], True))
            # check sharing state
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/bruce.prf"))._shared, True)
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/demi.prf"))._shared, True)
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/.svn"))._shared, False)
            # check tag
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/bruce.prf"))._tag, u"first")
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/demi.prf"))._tag, DEFAULT_TAG)
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/.svn"))._tag, u"first")

    def test_get_shared_files(self):
        document = CacheDocument()
        document.add_repository(REPO)
        document.add((abspath(u"data")))
        document.share_file((abspath(u"data"), True))
        document.share_file((abspath(u"data/.path"), True))
        document.share_files((abspath(u"data/profiles"),
                              ["bruce.prf", "demi.prf"],
                              True))
        document.share_files((REPO + "/data/subdir1",
                              ["date.doc"],
                              True))
        shared_files = [file_container.path for file_container
                        in document.get_shared_files()[REPO]]
        shared_files.sort()
        self.assertEquals(shared_files, [REPO + "/data/.path",
                                         REPO + "/data/date.txt",
                                         REPO + "/data/profiles/bruce.prf",
                                         REPO + "/data/profiles/demi.prf",
                                         REPO + "/data/routage",
                                         REPO + "/data/subdir1/date.doc"])

    def test_multiple_repos(self):
        """coherency when several repos in use"""
        document = CacheDocument()
        # create 2 repos
        document.add_repository(REPO + "/data/profiles")
        document.tag_files((REPO + "/data/profiles", ["bruce.prf", ".svn"], u"first"))
        document.share_files((REPO + "/data/profiles", ["bruce.prf", "demi.prf"], True))
        document.add_repository(REPO + "/data/subdir1")
        document.tag_files((REPO + "/data/subdir1", ["date.doc", ".svn"], u"second"))
        document.share_files((REPO + "/data/subdir1", ["date.doc", "subsubdir"], True))
        # check sharing state
        self.assertEquals(document.get_container(
            abspath("data/profiles/bruce.prf"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/profiles/demi.prf"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/profiles/.svn"))._shared, False)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/date.doc"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/subsubdir"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/.svn"))._shared, False)
        # check tag
        self.assertRaises(ValueError, document.add_repository, REPO + "/data/subdir1/subsubdir")
        self.assertRaises(ValueError, document.add_repository, REPO + "/data")
            
    # OTHERS TAB
    def test_reset_peers(self):
        """reset peers"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_peers)
        self.assertRaises(NotImplementedError, self.abstract_doc.reset_peers)
        document = self.documents[0]
        document.add_peer(u"nico")
        self.assertEquals(document.has_peer(u"nico"), True)
        document.reset_peers()
        self.assertEquals(document.has_peer(u"nico"), False)
        self.assertEquals(document.get_peers(), {})
            
    def test_adding_peer(self):
        self.assertRaises(NotImplementedError, self.abstract_doc.add_peer, "nico")
        """add peer"""
        document = self.documents[0]
        self.assertEquals(document.has_peer(u"nico"), False)
        document.add_peer(u"nico")
        self.assert_(document.has_peer(u"nico"))
            
    def test_getting_peer(self):
        """get peer"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_peer, "nico")
        for document in self.documents:
            document.add_peer(u"nico")
            peer_desc = document.get_peer(u"nico")
            self.assertEquals(peer_desc.peer_id, u"nico")
            
    def test_removing_peer(self):
        """remove peer"""
        self.assertRaises(NotImplementedError, self.abstract_doc.remove_peer, "nico")
        document = self.documents[0]
        document.add_peer(u"nico")
        self.assertEquals(document.has_peer(u"nico"), True)
        document.remove_peer(u"nico")
        self.assertEquals(document.has_peer(u"nico"), False)
        
    def test_filling_data(self):
        """fill data"""
        for document in self.documents:
            self.assertRaises(TypeError, document.fill_data,
                              (u"pseudo", u"tag description"))
            self.assertEquals(document.has_peer(u"emb"), False)
            file_doc = FileDocument()
            file_doc.load(TEST_PROFILE)
            document.fill_data((u"emb", file_doc))
    
    def test_peers_status(self):
        """change status"""
        document = self.documents[0]
        # friend
        document.make_friend(u"nico")
        self.assertEquals(PeerDescriptor.FRIEND,
                          document.get_peer(u"nico").state)
        # blacklist
        document.blacklist_peer(u"nico")
        self.assertEquals(PeerDescriptor.BLACKLISTED,
                          document.get_peer(u"nico").state)
        # anonmyous
        document.unmark_peer(u"nico")
        self.assertEquals(PeerDescriptor.ANONYMOUS,
                          document.get_peer(u"nico").state)
コード例 #5
0
class DocumentTest(unittest.TestCase):
    """test that all fields are correctly validated"""

    def setUp(self):
        """override one in unittest.TestCase"""
        self.documents = [CacheDocument(PROFILE_TEST, PROFILE_DIRECTORY),
                          FileDocument(PROFILE_TEST, PROFILE_DIRECTORY)]
        for document in self.documents:
            document.add_file(REPO)
        self.abstract_doc = AbstractDocument(PROFILE_TEST, PROFILE_DIRECTORY)
        self.abstract_doc.add_file(REPO)

    def test_config_parser(self):
        writer = CustomConfigParser(ENCODING)
        writer.add_section('TEST')
        writer.set('TEST', "Windows:path", "not a valid linux:path!")
        writer.write(open("generated/config.test", "w"))
        # standard reader
        reader = ConfigParser()
        reader.readfp(open("generated/config.test"))
        self.assert_(reader.has_section('TEST'))
        self.assert_(reader.has_option('TEST', "Windows"))
        self.assertEquals(reader.get('TEST', "Windows"), "path = not a valid linux:path!")
        # custom reader
        reader = CustomConfigParser(ENCODING)
        reader.readfp(open("generated/config.test"))
        self.assert_(reader.has_section('TEST'))
        self.assert_(reader.has_option('TEST', "Windows:path"))
        self.assertEquals(reader.get('TEST', "Windows:path"), "not a valid linux:path!")

    # PERSONAL TAB
    def test_title(self):
        """title as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_title)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_title, "Mr")
            self.assertRaises(TypeError, document.set_title, [u"Mr", ])
            document.set_title(u"Mr")
        
    def test_firstname(self):
        """firstname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_firstname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_firstname, "manu")
            self.assertRaises(TypeError, document.set_firstname, [u"manu", ])
            document.set_firstname(u"manu")
        
    def test_lastname(self):
        """lastname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_lastname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_lastname, "breton")
            self.assertRaises(TypeError, document.set_lastname, [u"breton", ])
            document.set_lastname(u"breton")
    
    def test_photo(self):
        """photo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_photo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_photo, "./dummy/dummy.jpg")
            document.set_photo(unicode(unittest.__file__, ENCODING))
        
    def test_email(self):
        """email as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_email)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_email, "*****@*****.**")
            self.assertRaises(TypeError, document.set_email, [u"manu@ft", ])
            document.set_email(u"*****@*****.**")
        
    # CUSTOM TAB
    def test_custom_attributes(self):
        """custom_attributes as pair of key/unicode-value"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_custom_attributes)
        for document in self.documents:
            self.assertRaises(TypeError, document.add_custom_attributes,
                              "homepage: manu.com")
            self.assertRaises(TypeError, document.add_custom_attributes,
                              ("homepage", "manu.com", "yo"))
            self.assertRaises(TypeError, document.add_custom_attributes,
                              ("homepage", "manu.com"))
            document.add_custom_attributes((u"homepage", u"manu.com"))
            self.assertRaises(TypeError, document.remove_custom_attributes,
                              "homepage")
            document.remove_custom_attributes(u"homepage")
        
    # FILE TAB
    def test_reset_files(self):
        """reset files"""
        for document in self.documents:
            document.add((abspath("data")))
            document.share_file((abspath("data"), True))
            self.assertEquals(document.get_container(abspath("data"))._shared, True)
            document.reset_files()
            self.assertEquals(document.get_files(), {})
        
    def test_repository(self):
        """repository valid path"""
        for document in self.documents:
            self.assertRaises(TypeError, document.add, abspath(u"data/dummy"))
            document.add(abspath("data"))
            document.remove(abspath("data"))
        
    def test_recursive_share(self):
        """share dir giving unicode name"""
        for document in self.documents:
            document.add((abspath("data")))
            self.assertRaises(KeyError, document.recursive_share, ("data", True))
            self.assertRaises(TypeError, document.recursive_share, (abspath(u"data"), True))
            document.recursive_share((abspath("data"), True))
        
    def test_share_files(self):
        """share files giving root & unicode names"""
        for document in self.documents:
            document.add((abspath("data")))
            self.assertRaises(TypeError, document.share_files,
                              "data, ['.path', 'routage'], True")
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage'], True"))
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage']", "True"))
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage']", True))
            document.share_files((abspath("data"), ['.path', 'routage'], True))
            document.share_files([abspath("data"), ['.path', 'routage'], True])
        
    def test_tag_file(self):
        """tag files giving root & unicode names"""
        for document in self.documents:
            document.add((abspath("data")))
            self.assertRaises(TypeError, document.tag_files,
                              "data, ['.path', 'routage'], tag desc")
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage'], tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage']", "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", ['.path', 'routage'], "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage']", "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", ['.path', 'routage'], "tag desc"))
            document.tag_files((abspath("data"), ['.path', 'routage'], u"tag desc"))
            document.tag_files([abspath("data"), ['.path', 'routage'], u"tag desc"])
        
    def test_add_file(self):
        """expand dir giving unicode name"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_files)
        for document in self.documents:
            document.add((abspath("data")))
            self.assertRaises(TypeError, document.expand_dir, u"data/dummy")
            self.assertRaises(TypeError, document.expand_dir, u"data")
            document.expand_dir((abspath("data")))

    def test_get_container(self):
        for document in self.documents:
            document.tag_files((abspath("data/profiles"),
                               ["bruce.prf", ".svn"], u"first"))
            document.share_files((abspath("data/profiles"),
                                  ["bruce.prf", "demi.prf"], False))
            # check sharing state
            self.assertEquals(document.get_container(
                abspath("data/profiles/bruce.prf"))._shared, False)
            self.assertEquals(document.get_container(
                abspath("data/profiles/demi.prf"))._shared, False)
            self.assertEquals(document.get_container(
                abspath("data/profiles/.svn"))._shared, True)
            # check tag
            self.assertEquals(document.get_container(
                abspath("data/profiles/bruce.prf"))._tag, u"first")
            self.assertEquals(document.get_container(
                abspath("data/profiles/demi.prf"))._tag, DEFAULT_TAG)
            self.assertEquals(document.get_container(
                abspath("data/profiles/.svn"))._tag, u"first")

    def test_get_shared_files(self):
        document = CacheDocument(PROFILE_TEST, PROFILE_DIRECTORY)
        document.add_file(REPO)
        document.expand_dir(abspath("data"))
        document.expand_dir(abspath("data/subdir1"))
        document.share_files((abspath("data"),
                              [REPO + '/data/.path',
                               REPO + '/data/.svn',
                               REPO + '/data/date.txt',
                               REPO + '/data/emptydir',
                               REPO + '/data/profiles',
                               REPO + '/data/subdir1/.svn',
                               REPO + '/data/subdir1/subsubdir'],
                              False))
        document.share_files((abspath("data"),
                              [REPO + '/data',
                               REPO + "/data/.path",
                               REPO + "/data/date.txt",
                               REPO + "/data/routage",
                               REPO + '/data/subdir1',
                               REPO + "/data/subdir1/TOtO.txt",
                               REPO + "/data/subdir1/date.doc"],
                              True))
        shared_files = [file_container.get_path() for file_container
                        in document.get_shared_files()[REPO]]
        shared_files.sort()
        self.assertEquals(shared_files, [REPO + "/data/.path",
                                         REPO + "/data/date.txt",
                                         REPO + "/data/routage",
                                         REPO + "/data/subdir1/TOtO.txt",
                                         REPO + "/data/subdir1/date.doc"])
        
    def test_multiple_repos(self):
        """coherency when several repos in use"""
        document = CacheDocument(PROFILE_TEST, PROFILE_DIRECTORY)
        # create 2 repos
        document.add_file(REPO + "/data/profiles")
        document.tag_files((REPO + "/data/profiles", ["bruce.prf", ".svn"], u"first"))
        document.share_files((REPO + "/data/profiles", ["bruce.prf", "demi.prf"], False))
        document.add_file(REPO + "/data/subdir1")
        document.tag_files((REPO + "/data/subdir1", ["date.doc", ".svn"], u"second"))
        document.share_files((REPO + "/data/subdir1", ["date.doc", "subsubdir"], False))
        # check sharing state
        self.assertEquals(document.get_container(
            abspath("data/profiles/bruce.prf"))._shared, False)
        self.assertEquals(document.get_container(
            abspath("data/profiles/demi.prf"))._shared, False)
        self.assertEquals(document.get_container(
            abspath("data/profiles/.svn"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/date.doc"))._shared, False)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/subsubdir"))._shared, False)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/.svn"))._shared, True)
        # check tag
        self.assertRaises(ValueError, document.add_file, REPO + "/data/subdir1/subsubdir")
        self.assertRaises(ValueError, document.add_file, REPO + "/data")
            
    # OTHERS TAB
    def test_reset_peers(self):
        """reset peers"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_peers)
        self.assertRaises(NotImplementedError, self.abstract_doc.reset_peers)
        document = self.documents[0]
        document.set_peer((u"nico", PeerDescriptor(PSEUDO)))
        self.assertEquals(document.has_peer(u"nico"), True)
        document.reset_peers()
        self.assertEquals(document.has_peer(u"nico"), False)
        self.assertEquals(document.get_peers(), {})
            
    def test_getting_peer(self):
        """get peer"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_peer, "nico")
        for document in self.documents:
            document.set_peer((u"nico", PeerDescriptor(PSEUDO)))
            peer_desc = self.documents[0].get_peer(u"nico")
            self.assertEquals(peer_desc.pseudo, PSEUDO)
            
    def test_removing_peer(self):
        """remove peer"""
        self.assertRaises(NotImplementedError, self.abstract_doc.remove_peer, "nico")
        for document in self.documents:
            document.set_peer((u"nico", PeerDescriptor(PSEUDO)))
            self.assertEquals(document.has_peer(u"nico"), True)
            document.remove_peer(u"nico")
            self.assertEquals(document.has_peer(u"nico"), False)
        
    def test_filling_data(self):
        """fill data"""
        for document in self.documents:
            self.assertEquals(document.has_peer(u"emb"), False)
            file_doc = FileDocument(PROFILE_TEST, PROFILE_DIRECTORY)
            file_doc.load()
            document.fill_data((u"emb", file_doc))
    
    def test_peers_status(self):
        """change status"""
        for document in self.documents:
            self.assertRaises(AssertionError, document.make_friend, u"nico")
            self.assertRaises(AssertionError, document.blacklist_peer, u"nico")
            self.assertRaises(AssertionError, document.unmark_peer, u"nico")
            document.set_peer((u"nico", PeerDescriptor(PROFILE_TEST)))
            # friend
            document.make_friend(u"nico")
            self.assertEquals(PeerDescriptor.FRIEND,
                              document.get_peer(u"nico").state)
            # blacklist
            document.blacklist_peer(u"nico")
            self.assertEquals(PeerDescriptor.BLACKLISTED,
                              document.get_peer(u"nico").state)
            # anonmyous
            document.unmark_peer(u"nico")
            self.assertEquals(PeerDescriptor.ANONYMOUS,
                              document.get_peer(u"nico").state)
コード例 #6
0
class DocumentTest(unittest.TestCase):
    """test that all fields are correctly validated"""

    def setUp(self):
        """override one in unittest.TestCase"""
        self.documents = [CacheDocument(), FileDocument()]
        for document in self.documents:
            document.add_repository(REPO)
        self.abstract_doc = AbstractDocument()
        self.abstract_doc.add_repository(REPO)

    # PERSONAL TAB
    def test_title(self):
        """title as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_title)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_title, "Mr")
            self.assertRaises(TypeError, document.set_title, [u"Mr", ])
            document.set_title(u"Mr")
        
    def test_firstname(self):
        """firstname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_firstname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_firstname, "manu")
            self.assertRaises(TypeError, document.set_firstname, [u"manu", ])
            document.set_firstname(u"manu")
        
    def test_lastname(self):
        """lastname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_lastname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_lastname, "breton")
            self.assertRaises(TypeError, document.set_lastname, [u"breton", ])
            document.set_lastname(u"breton")
    
    def test_pseudo(self):
        """pseudo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_pseudo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_pseudo, "emb")
            self.assertRaises(TypeError, document.set_pseudo, [u"manu", u"emb"])
            document.set_pseudo(u"emb")
    
    def test_photo(self):
        """photo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_photo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_photo, "./dummy/dummy.jpg")
            document.set_photo(unittest.__file__)
        
    def test_email(self):
        """email as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_email)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_email, "*****@*****.**")
            self.assertRaises(TypeError, document.set_email, [u"manu@ft", ])
            document.set_email(u"*****@*****.**")
        
    def test_birthday(self):
        """birthday as DateTime convertable"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_birthday)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_birthday, "12 jan 2005")
            self.assertRaises(TypeError, document.set_birthday, "2005/01/12")
            self.assertRaises(TypeError, document.set_birthday, "12-01-2005")
            self.assertRaises(TypeError, document.set_birthday, "12012005")
            self.assertRaises(TypeError, document.set_birthday, "12/01")
            self.assertRaises(TypeError, document.set_birthday, ["12/01/05", ])
            document.set_birthday(u"12/01/2005")
            document.set_birthday("12/01/2005")
            
    def test_language(self):
        """language as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_language)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_language, "fr")
            self.assertRaises(TypeError, document.set_language, [u"fr", u"sp"])
            document.set_language(u"fr")
        
    def test_address(self):
        """address as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_address)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_address, "12 rue V Hugo")
            self.assertRaises(TypeError, document.set_address, [u"12",
                                                                u"rue V Hugo"])
            document.set_address(u"12 rue V Hugo")
        
    def test_postcode(self):
        """postcode as int convertable"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_postcode)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_postcode, "34.000")
            self.assertRaises(TypeError, document.set_postcode, "34 000")
            self.assertRaises(TypeError, document.set_postcode, "Herault")
            self.assertRaises(TypeError, document.set_birthday, ["34", ])
            document.set_postcode(u"34000")
            document.set_postcode("34000")
        
    def test_city(self):
        """city as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_city)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_city, "Paris")
            self.assertRaises(TypeError, document.set_city, [u"Paris", ])
            document.set_city(u"Paris")
        
    def test_country(self):
        """country as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_country)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_country, "France")
            self.assertRaises(TypeError, document.set_country, [u"France", ])
            document.set_country(u"France")
        
    def test_description(self):
        """description as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_description)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_description, "anything")
            self.assertRaises(TypeError, document.set_description, [u"anything", ])
            document.set_description(u"anything")
        
    # CUSTOM TAB
    def test_hobbies(self):
        """hobbies as unicode (multiple lines)"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_hobbies)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_hobbies,
                              "blabla\nbla bla bla\n")
            self.assertRaises(TypeError, document.set_hobbies,
                              u"blabla\nbla bla bla\n")
            document.set_hobbies([u"blabla", u"bla bla bla", u""])
        
    def test_custom_attributes(self):
        """custom_attributes as pair of key/unicode-value"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_custom_attributes)
        for document in self.documents:
            self.assertRaises(TypeError, document.add_custom_attributes,
                              "homepage: manu.com")
            self.assertRaises(TypeError, document.add_custom_attributes,
                              ("homepage", "manu.com", "yo"))
            self.assertRaises(TypeError, document.add_custom_attributes,
                              ("homepage", "manu.com"))
            document.add_custom_attributes((u"homepage", u"manu.com"))
            self.assertRaises(TypeError, document.remove_custom_attributes,
                              "homepage")
            document.remove_custom_attributes(u"homepage")
        
    # FILE TAB
    def test_reset_files(self):
        """reset files"""
        for document in self.documents:
            document.add((abspath(u"data")))
            document.share_file((abspath(u"data"), True))
            self.assertEquals(document.get_container(abspath(u"data"))._shared, True)
            document.reset_files()
            self.assertEquals(document.get_files(), {})
        
    def test_repository(self):
        """repository valid path"""
        for document in self.documents:
            self.assertRaises(TypeError, document.add, abspath("data/dummy"))
            document.add(abspath(u"data"))
            document.remove(abspath(u"data"))
        
    def test_share_dir(self):
        """share dir giving unicode name"""
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.share_dirs, "data, True")
            self.assertRaises(TypeError, document.share_dirs, ("data", ))
            self.assertRaises(TypeError, document.share_dirs, ("data", True))
            self.assertRaises(TypeError, document.share_dirs, (abspath(u"data"), True))
            document.share_dirs(([abspath(u"data")], True))
            document.share_dirs([[abspath(u"data")], True])
        
    def test_share_files(self):
        """share files giving root & unicode names"""
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.share_files,
                              "data, ['.path', 'routage'], True")
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage'], True"))
            self.assertRaises(TypeError, document.share_files,
                              ("data", "['.path', 'routage']", "True"))
            self.assertRaises(TypeError, document.share_files,
                              (u"data", "['.path', 'routage']", True))
            self.assertRaises(TypeError, document.share_files,
                              ("data", ['.path', 'routage'], True))
            document.share_files((abspath(u"data"), ['.path', 'routage'], True))
            document.share_files([abspath(u"data"), ['.path', 'routage'], True])
        
    def test_tag_file(self):
        """tag files giving root & unicode names"""
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.tag_files,
                              "data, ['.path', 'routage'], tag desc")
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage'], tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", "['.path', 'routage']", "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              ("data", ['.path', 'routage'], "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              (u"data", "['.path', 'routage']", "tag desc"))
            self.assertRaises(TypeError, document.tag_files,
                              (u"data", ['.path', 'routage'], "tag desc"))
            document.tag_files((abspath(u"data"), ['.path', 'routage'], u"tag desc"))
            document.tag_files([abspath(u"data"), ['.path', 'routage'], u"tag desc"])
        
    def test_add_file(self):
        """expand dir giving unicode name"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_files)
        for document in self.documents:
            document.add((abspath(u"data")))
            self.assertRaises(TypeError, document.expand_dir, "data/dummy")
            self.assertRaises(TypeError, document.expand_dir, "data")
            document.expand_dir((abspath(u"data")))

    def test_get_container(self):
        """retreive correct contaier"""
        for document in self.documents:
            document.tag_files((abspath(u"data/profiles"),
                               ["bruce.prf", ".svn"], u"first"))
            document.share_files((abspath(u"data/profiles"),
                                  ["bruce.prf", "demi.prf"], True))
            # check sharing state
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/bruce.prf"))._shared, True)
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/demi.prf"))._shared, True)
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/.svn"))._shared, False)
            # check tag
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/bruce.prf"))._tag, u"first")
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/demi.prf"))._tag, DEFAULT_TAG)
            self.assertEquals(document.get_container(
                abspath(u"data/profiles/.svn"))._tag, u"first")

    def test_multiple_repos(self):
        """coherency when several repos in use"""
        document = CacheDocument()
        # create 2 repos
        document.add_repository(REPO + "/data/profiles")
        document.tag_files((REPO + "/data/profiles", ["bruce.prf", ".svn"], u"first"))
        document.share_files((REPO + "/data/profiles", ["bruce.prf", "demi.prf"], True))
        document.add_repository(REPO + "/data/subdir1")
        document.tag_files((REPO + "/data/subdir1", ["date.doc", ".svn"], u"second"))
        document.share_files((REPO + "/data/subdir1", ["date.doc", "subsubdir"], True))
        # check sharing state
        self.assertEquals(document.get_container(
            abspath("data/profiles/bruce.prf"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/profiles/demi.prf"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/profiles/.svn"))._shared, False)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/date.doc"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/subsubdir"))._shared, True)
        self.assertEquals(document.get_container(
            abspath("data/subdir1/.svn"))._shared, False)
        # check tag
        self.assertRaises(ValueError, document.add_repository, REPO + "/data/subdir1/subsubdir")
        self.assertRaises(ValueError, document.add_repository, REPO + "/data")
            
    # OTHERS TAB
    def test_reset_peers(self):
        """reset files"""
        for document in self.documents:
            document.add_peer(u"nico")
            self.assert_(document.get_peers().has_key(u"nico"))
            document.reset_peers()
            self.assertEquals(document.get_peers(), {})
            
    def test_adding_peer(self):
        self.assertRaises(NotImplementedError, self.abstract_doc.get_peers)
        """pseudo as unicode"""
        for document in self.documents:
            self.assertRaises(TypeError, document.add_peer, "nico")
            self.assertRaises(TypeError, document.add_peer, [u"nico", ])
            document.add_peer(u"nico")
            
    def test_removing_peer(self):
        """pseudo as unicode"""
        for document in self.documents:
            self.assertRaises(TypeError, document.remove_peer, "nico")
            self.assertRaises(TypeError, document.remove_peer, [u"nico", ])
            document.remove_peer(u"nico")
        
    def test_filling_data(self):
        """data as (pseudo, document)"""
        for document in self.documents:
            self.assertRaises(TypeError, document.fill_data,
                              "pseudo: doc")
            self.assertRaises(TypeError, document.fill_data,
                              ("pseudo", ))
            self.assertRaises(TypeError, document.fill_data,
                              ("pseudo", "doc"))
            self.assertRaises(TypeError, document.fill_data,
                              (u"pseudo", u"tag description"))
            self.assertRaises(TypeError, document.fill_data,
                              ("pseudo", AbstractDocument()))
            document.fill_data((u"emb", AbstractDocument()))
            document.fill_data((u"emb", FileDocument()))
            document.fill_data((u"emb", CacheDocument()))
    
    def test_peers_status(self):
        """action changes to accurate state"""
        for document in self.documents:
            # friend
            self.assertRaises(TypeError, document.make_friend, "pseudo")
            document.make_friend(u"nico")
            self.assertEquals(PeerDescriptor.FRIEND,
                              document.get_peers()[u"nico"][0].state)

            # blacklist
            self.assertRaises(TypeError, document.blacklist_peer, "pseudo")
            document.blacklist_peer(u"nico")
            self.assertEquals(PeerDescriptor.BLACKLISTED,
                              document.get_peers()[u"nico"][0].state)
            # anonmyous
            self.assertRaises(TypeError, document.unmark_peer, "pseudo")
            document.unmark_peer(u"nico")
            self.assertEquals(PeerDescriptor.ANONYMOUS,
                              document.get_peers()[u"nico"][0].state)
コード例 #7
0
class DocumentTest(unittest.TestCase):
    """test that all fields are correctly validated"""

    def setUp(self):
        """override one in unittest.TestCase"""
        write_test_profile()
        self.documents = [CacheDocument(),
                          FileDocument()]
        for document in self.documents:
            document.add_repository(TEST_DIR)
        self.abstract_doc = AbstractDocument()
        self.abstract_doc.add_repository(TEST_DIR)

    def test_config_parser(self):
        writer = CustomConfigParser(ENCODING)
        writer.add_section("TEST")
        writer.set("TEST", "Windows:path", "not a valid linux:path!")
        writer.write(open(os.path.join("generated", "config.test"), "w"))
        # standard reader
        reader = ConfigParser()
        reader.readfp(open(os.path.join("generated", "config.test")))
        self.assert_(reader.has_section("TEST"))
        self.assert_(reader.has_option("TEST", "Windows"))
        self.assertEquals(reader.get("TEST", "Windows"), "path = not a valid linux:path!")
        # custom reader
        reader = CustomConfigParser(ENCODING)
        reader.readfp(open(os.path.join("generated", "config.test")))
        self.assert_(reader.has_section("TEST"))
        self.assert_(reader.has_option("TEST", "Windows:path"))
        self.assertEquals(reader.get("TEST", "Windows:path"), "not a valid linux:path!")

    # PERSONAL TAB
    def test_pseudo(self):
        """pseudo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_pseudo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_pseudo, "atao")
            self.assertRaises(TypeError, document.set_pseudo, [u"atao", ])
            document.set_pseudo(u"atao")
            
    def test_title(self):
        """title as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_title)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_title, "Mr")
            self.assertRaises(TypeError, document.set_title, [u"Mr", ])
            document.set_title(u"Mr")
        
    def test_firstname(self):
        """firstname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_firstname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_firstname, "manu")
            self.assertRaises(TypeError, document.set_firstname, [u"manu", ])
            document.set_firstname(u"manu")
        
    def test_lastname(self):
        """lastname as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_lastname)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_lastname, "breton")
            self.assertRaises(TypeError, document.set_lastname, [u"breton", ])
            document.set_lastname(u"breton")
    
    def test_photo(self):
        """photo as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_photo)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_photo, "./dummy/dummy.jpg")
            document.set_photo(force_unicode(unittest.__file__))
        
    def test_email(self):
        """email as unicode"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_email)
        for document in self.documents:
            self.assertRaises(TypeError, document.set_email, "*****@*****.**")
            self.assertRaises(TypeError, document.set_email, [u"manu@ft", ])
            document.set_email(u"*****@*****.**")
        
    # CUSTOM TAB
    def test_custom_attributes(self):
        """custom_attributes as pair of key", "unicode-value"""
        self.assertRaises(NotImplementedError, self.abstract_doc.get_custom_attributes)
        for document in self.documents:
            self.assertRaises(TypeError, document.add_custom_attributes,
                              "homepage", "manu.com")
            document.add_custom_attributes(u"homepage", u"manu.com")
            self.assertRaises(TypeError, document.remove_custom_attributes,
                              "homepage")
            document.remove_custom_attributes(u"homepage")
        
    # FILE TAB
    def test_reset_files(self):
        """reset files"""
        for document in self.documents:
            document.share_file(abspath("data"), True)
            self.assertEquals(document.get_container(abspath("data"))._shared, True)
            document.reset_files()
            self.assertEquals(document.get_files(), {})
        
    def test_recursive_share(self):
        """share dir giving unicode name"""
        for document in self.documents:
            self.assertRaises(TypeError, document.recursive_share, abspath(u"data"), True)
            self.assertEquals(1, len(document.recursive_share("data", True)))
            self.assertEquals([], document.recursive_share(abspath("data"), True))
        
    def test_share_files(self):
        """share files giving root & unicode names"""
        for document in self.documents:
            document.share_files(abspath("data"), [".path", "routage"], True)
        
    def test_set_container(self):
        path = os.path.join(abspath("data"), "date.txt")
        container = FileContainer(path,
                                  share=True,
                                  tag=u"Shared by set_container")
        for document in self.documents:
            self.assertEquals(document.get_container(path)._shared, False)
            self.assertEquals(document.get_container(path)._tag, DEFAULT_TAG)
            document.set_container(container)
            self.assertEquals(document.get_container(path)._shared, True)
            self.assertEquals(document.get_container(path)._tag, u"Shared by set_container")
        
    def test_add_repository(self):
        """expand dir giving unicode name"""
        for document in self.documents:
            self.assertRaises(TypeError, document.expand_dir, os.path.join(u"data", "dummy"))
            self.assertRaises(TypeError, document.expand_dir, u"data")
            document.expand_dir(abspath("data"))

    def test_get_container(self):
        for document in self.documents:
            tag_files(document, abspath(os.path.join("data", "profiles")),
                               ["bruce.prf", ".svn"], u"first")
            document.share_files(abspath(os.path.join("data", "profiles")),
                                  ["bruce.prf", "demi.prf"], True)
            # check sharing state
            self.assertEquals(document.get_container(
                abspath(os.sep.join(["data", "profiles", "bruce.prf"])))._shared, True)
            self.assertEquals(document.get_container(
                abspath(os.sep.join(["data", "profiles", "demi.prf"])))._shared, True)
            self.assertEquals(document.get_container(
                abspath(os.sep.join(["data", "profiles", ".svn"])))._shared, False)
            # check tag
            self.assertEquals(document.get_container(
                abspath(os.sep.join(["data", "profiles", "bruce.prf"])))._tag, u"first")
            self.assertEquals(document.get_container(
                abspath(os.sep.join(["data", "profiles", "demi.prf"])))._tag, DEFAULT_TAG)
            self.assertEquals(document.get_container(
                abspath(os.sep.join(["data", "profiles", ".svn"])))._tag, u"first")

    def test_get_shared_files(self):
        document = CacheDocument()
        document.add_repository(TEST_DIR)
        document.expand_dir(abspath("data"))
        document.expand_dir(abspath(os.path.join("data", "subdir1")))
        document.share_files(abspath("data"),
                              [os.sep.join([TEST_DIR, "data", ".path"]),
                               os.sep.join([TEST_DIR, "data", ".svn"]),
                               os.sep.join([TEST_DIR, "data", "date.txt"]),
                               os.sep.join([TEST_DIR, "data", "emptydir"]),
                               os.sep.join([TEST_DIR, "data", "profiles"]),
                               os.sep.join([TEST_DIR, "data", "subdir1", ".svn"]),
                               os.sep.join([TEST_DIR, "data", "subdir1", "subsubdir"])],
                              False)
        document.share_files(abspath("data"),
                              [os.sep.join([TEST_DIR, "data"]),
                               os.sep.join([TEST_DIR, "data", ".path"]),
                               os.sep.join([TEST_DIR, "data", "date.txt"]),
                               os.sep.join([TEST_DIR, "data", "routage"]),
                               os.sep.join([TEST_DIR, "data", "subdir1"]),
                               os.sep.join([TEST_DIR, "data", "subdir1", "TOtO.txt"]),
                               os.sep.join([TEST_DIR, "data", "subdir1", "date.doc"])],
                              True)
        shared_files = [file_container.get_path() for file_container
                        in document.get_shared_files()[TEST_DIR]]
        shared_files.sort()
        self.assertEquals(shared_files, [os.sep.join([TEST_DIR, "data", ".path"]),
                                         os.sep.join([TEST_DIR, "data", "02_b_1280x1024.jpg"]),
                                         os.sep.join([TEST_DIR, "data", "Python-2.3.5.zip"]),
                                         os.sep.join([TEST_DIR, "data", "arc en ciel 6.gif"]),
                                         os.sep.join([TEST_DIR, "data", "date.txt"]),
                                         os.sep.join([TEST_DIR, "data", "pywin32-203.win32-py2.3.exe"]),
                                         os.sep.join([TEST_DIR, "data", "routage"]),
                                         os.sep.join([TEST_DIR, "data", "subdir1", "TOtO.txt"]),
                                         os.sep.join([TEST_DIR, "data", "subdir1", "date.doc"])])
        
    def test_multiple_repos(self):
        """coherency when several repos in use"""
        document = CacheDocument()
        # create 2 repos
        document.add_repository(os.sep.join([TEST_DIR, "data", "profiles"]))
        tag_files(document, os.sep.join([TEST_DIR, "data", "profiles"]), ["bruce.prf", ".svn"], u"first")
        document.share_files(os.sep.join([TEST_DIR, "data", "profiles"]), ["bruce.prf", "demi.prf"], True)
        document.add_repository(os.sep.join([TEST_DIR, "data", "subdir1"]))
        tag_files(document, os.sep.join([TEST_DIR, "data", "subdir1"]), ["date.doc", ".svn"], u"second")
        document.share_files(os.sep.join([TEST_DIR, "data", "subdir1"]), ["date.doc", "subsubdir"], True)
        # check sharing state
        self.assertEquals(document.get_container(
            abspath(os.sep.join(["data", "profiles", "bruce.prf"])))._shared, True)
        self.assertEquals(document.get_container(
            abspath(os.sep.join(["data", "profiles", "demi.prf"])))._shared, True)
        self.assertEquals(document.get_container(
            abspath(os.sep.join(["data", "profiles", ".svn"])))._shared, False)
        self.assertEquals(document.get_container(
            abspath(os.sep.join(["data", "subdir1", "date.doc"])))._shared, True)
        self.assertEquals(document.get_container(
            abspath(os.sep.join(["data", "subdir1", "subsubdir"])))._shared, True)
        self.assertEquals(document.get_container(
            abspath(os.sep.join(["data", "subdir1", ".svn"])))._shared, False)
        # check tag
        self.assertRaises(ContainerException, document.add_repository, os.sep.join([TEST_DIR, "data", "subdir1", "subsubdir"]))
        self.assertRaises(ContainerException, document.add_repository, os.sep.join([TEST_DIR, "data"]))
            
    # OTHERS TAB
    def test_reset_peers(self):
        """reset peers"""
        document = self.documents[0]
        document.set_peer(u"nico", PeerDescriptor(PROFILE_TEST))
        self.assertEquals(document.has_peer(u"nico"), True)
        document.reset_peers()
        self.assertEquals(document.has_peer(u"nico"), False)
        self.assertEquals(document.get_peers(), {})
            
    def test_getting_peer(self):
        """get peer"""
        for document in self.documents:
            document.set_peer(PROFILE_BRUCE, PeerDescriptor(PROFILE_BRUCE))
            peer_desc = self.documents[0].get_peer(PROFILE_BRUCE)
            self.assertEquals(peer_desc.node_id, PROFILE_BRUCE)
            
    def test_removing_peer(self):
        """remove peer"""
        for document in self.documents:
            document.set_peer(u"nico", PeerDescriptor(PROFILE_TEST))
            self.assertEquals(document.has_peer(u"nico"), True)
            document.remove_peer(u"nico")
            self.assertEquals(document.has_peer(u"nico"), False)
        
    def test_filling(self):
        """fill data"""
        for document in self.documents:
            self.assertEquals(document.has_peer(u"emb"), False)
            bruce = get_bruce_profile()
            document.fill_data(u"emb", bruce.document)
            document.fill_blog(u"emb", bruce.blog)
    
    def test_peers_status(self):
        """change status"""
        bruce = get_bruce_profile()
        for document in self.documents:
            self.assertRaises(AssertionError, document.make_friend, bruce.node_id)
            self.assertRaises(AssertionError, document.blacklist_peer, bruce.node_id)
            self.assertRaises(AssertionError, document.unmark_peer, bruce.node_id)
            document.set_peer(bruce.node_id, bruce)
            # friend
            document.make_friend(bruce.node_id)
            self.assertEquals(PeerDescriptor.FRIEND,
                              document.get_peer(bruce.node_id).state)
            # blacklist
            document.blacklist_peer(bruce.node_id)
            self.assertEquals(PeerDescriptor.BLACKLISTED,
                              document.get_peer(bruce.node_id).state)
            # anonmyous
            document.unmark_peer(bruce.node_id)
            self.assertEquals(PeerDescriptor.ANONYMOUS,
                              document.get_peer(bruce.node_id).state)