Python StorageServer.add_collection方法代码示例

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def __create_collection(self, account_id, collection_name):

        file = open('../test_resources/XooML.xml')
        StorageServer.add_collection(user_id= account_id,
            collection_name=collection_name, callback=self.stop, file= file)
        response = self.wait(timeout=100)
        self.assertEqual(StorageResponse.OK, response)

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_update_sharing_note(self):

        #create collection
        collection_name = 'shareable_collection'
        file = open('../test_resources/XooML.xml')
        StorageServer.add_collection(user_id=self.__account_id,
            collection_name=collection_name, callback=self.stop, file= file)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #add note
        note_name = "noteName"
        note_file = open('../test_resources/note.xml')
        StorageServer.add_note_to_collection(self.__account_id,
            collection_name, note_name, note_file, callback = self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #update note
        note_file = open('../test_resources/note2.xml')
        update_note_action = UpdateSharedNoteAction(self.__account_id, collection_name,
            note_name, note_file)
        update_note_action.execute(callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #cleanup
        StorageServer.remove_collection(self.__account_id, collection_name,
            callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_copy_collections_between_accounts_different_name(self):

        first_collection_name = str(uuid.uuid1())
        file = open("../test_resources/XooML.xml")
        StorageServer.add_collection(
            user_id=self.__account_id, collection_name=first_collection_name, callback=self.stop, file=file
        )
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        second_collection_name = str(uuid.uuid1())
        StorageServer.copy_collection_between_accounts(
            self.__account_id,
            self.__second_account_id,
            first_collection_name,
            second_collection_name,
            callback=self.stop,
        )
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        StorageServer.list_collections(self.__second_account_id, callback=self.stop)
        col_list = self.wait()
        self.assertTrue(second_collection_name in col_list)
        # cleanup
        StorageServer.remove_collection(self.__account_id, first_collection_name, callback=self.stop)
        self.wait()
        StorageServer.remove_collection(self.__second_account_id, second_collection_name, callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def __create_sharing_record(self, subscriber_list, collection_name):

        #create collection
        file = open('../test_resources/XooML.xml')
        StorageServer.add_collection(user_id=self.__account_id,
            collection_name= collection_name, callback=self.stop, file= file)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #create sharing record
        SharingController.create_sharing_record(self.__account_id,
            collection_name, callback = self.stop)
        sharing_secret = self.wait(timeout=10000)
        self.assertTrue(sharing_secret is not None)

        subscribers = {}
        for subscriber_id in subscriber_list:
            #subscribe
            SharingController.subscribe_to_sharing_space(subscriber_id,
                sharing_secret, callback = self.stop)
            subscribers_collection_name  = self.wait()
            self.assertTrue(subscribers_collection_name is not None)
            subscribers[subscriber_id] = subscribers_collection_name

        return sharing_secret, subscribers

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_update_sharing_thumbnail(self):

        first_collection_name = 'shareable_collection_thumbnail'
        file = open('../test_resources/XooML.xml')
        StorageServer.add_collection(user_id=self.__account_id,
            collection_name=first_collection_name, callback=self.stop, file= file)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #add thumbnail
        file = open('../test_resources/note_img.jpg')
        StorageServer.add_thumbnail(self.__account_id, first_collection_name,
            file, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #update thumnail action
        file = open('../test_resources/note_img2.jpg')
        update_thumbnail_action = UpdateSharedThumbnailAction(self.__account_id,
            first_collection_name, file)
        update_thumbnail_action.execute(callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        #cleanup
        StorageServer.remove_collection(self.__account_id, first_collection_name,
            callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_reshare_already_shared_collection(self):

        # create collection
        first_collection_name = "shareable_collection"
        file = open("../test_resources/XooML.xml")
        StorageServer.add_collection(
            user_id=self.__account_id, collection_name=first_collection_name, callback=self.stop, file=file
        )
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        # create sharing record
        SharingController.create_sharing_record(self.__account_id, first_collection_name, callback=self.stop)
        sharing_secret = self.wait()
        self.assertTrue(sharing_secret is not None)

        # duplicate create sharing record
        SharingController.create_sharing_record(self.__account_id, first_collection_name, callback=self.stop)
        new_sharing_secret = self.wait()
        self.assertEqual(sharing_secret, new_sharing_secret)

        # verify that only one sharing record was added
        SharingController.get_sharing_record_by_owner_info(self.__account_id, first_collection_name, callback=self.stop)
        sharing_record = self.wait()
        subscribers_list = sharing_record.get_subscribers()
        self.assertEqual(1, len(subscribers_list))

        # cleanup
        SharingController.remove_sharing_record_by_secret(sharing_secret, callback=self.stop)
        self.wait()
        StorageServer.remove_collection(self.__account_id, first_collection_name, callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_remove_all_subscribers(self):

        collection_name = "shareable_collection"
        file = open("../test_resources/XooML.xml")
        StorageServer.add_collection(
            user_id=self.__account_id, collection_name=collection_name, callback=self.stop, file=file
        )
        response = self.wait()

        self.assertEqual(StorageResponse.OK, response)

        SharingController.create_sharing_record(self.__account_id, collection_name, callback=self.stop)
        sharing_secret = self.wait()

        SharingController.subscribe_to_sharing_space(self.__subscriber_id, sharing_secret, callback=self.stop)
        collection_name2 = self.wait(timeout=500)

        SharingController.remove_all_subscribers(sharing_secret, callback=self.stop)
        self.wait(timeout=10000)

        # busy wait for the results of remove all subscribers to become consistent
        try:
            self.wait(timeout=5)
        except Exception:
            pass

        SharingController.get_sharing_secret_from_subscriber_info(
            self.__account_id, collection_name, callback=self.stop
        )
        actual_sharing_secret = self.wait()
        self.assertTrue(actual_sharing_secret is None)
        SharingController.get_sharing_secret_from_subscriber_info("second_user", collection_name2, callback=self.stop)
        actual_sharing_secret = self.wait()
        self.assertTrue(actual_sharing_secret is None)

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
 def test_remove_collection_with_no_file(self):
     collection_name = str(uuid.uuid1())
     StorageServer.add_collection(self.__account_id, collection_name, callback=self.stop)
     response = self.wait()
     self.assertEqual(StorageResponse.OK, response)
     StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
     response = self.wait()
     self.assertEqual(StorageResponse.OK, response)

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_rename_shared_collection_owner(self):

        # create collection
        first_collection_name = "shareable_collection" + str(random.randint)
        file = open("../test_resources/XooML.xml")
        StorageServer.add_collection(
            user_id=self.__account_id, collection_name=first_collection_name, callback=self.stop, file=file
        )
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        # create sharing record
        SharingController.create_sharing_record(self.__account_id, first_collection_name, callback=self.stop)
        sharing_secret = self.wait()
        self.assertTrue(sharing_secret is not None)

        # subscribe
        SharingController.subscribe_to_sharing_space(self.__subscriber_id, sharing_secret, callback=self.stop)
        subscribers_collection_name = self.wait()
        self.assertTrue(subscribers_collection_name is not None)

        # rename
        new_collection_name = "new_name" + str(random.randint)
        SharingController.rename_shared_collection(
            self.__account_id, first_collection_name, new_collection_name, callback=self.stop
        )
        response_code = self.wait()
        self.assertTrue(StorageResponse.OK, response_code)

        # verify
        SharingController.get_sharing_record_by_secret(sharing_secret, callback=self.stop)
        sharing_record = self.wait()
        renamed_collection_name = sharing_record.get_owner_collection_name()
        self.assertEqual(new_collection_name, renamed_collection_name)

        # verify owner collection
        SharingController.get_sharing_secret_from_subscriber_info(
            self.__account_id, new_collection_name, callback=self.stop
        )
        renamed_sharing_secret = self.wait()
        self.assertEqual(sharing_secret, renamed_sharing_secret)

        # verify subscriber collection
        SharingController.get_sharing_record_from_subscriber_info(
            self.__subscriber_id, subscribers_collection_name, callback=self.stop
        )
        renamed_sharing_record = self.wait()
        owner_collection_name = renamed_sharing_record.get_collection_name_for_subscriber(self.__account_id)
        self.assertEqual(new_collection_name, renamed_sharing_record.get_owner_collection_name())
        self.assertEqual(new_collection_name, owner_collection_name)

        # cleanup
        SharingController.remove_sharing_record_by_secret(sharing_secret, callback=self.stop)
        self.wait()
        StorageServer.remove_collection(self.__account_id, first_collection_name, callback=self.stop)
        self.wait()
        StorageServer.remove_collection(self.__subscriber_id, subscribers_collection_name, callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
 def test_remove_collection_with_file(self):
     collection_name = str(uuid.uuid1())
     file = open("../test_resources/XooML.xml")
     StorageServer.add_collection(
         user_id=self.__account_id, collection_name=collection_name, callback=self.stop, file=file
     )
     response = self.wait(timeout=10)
     self.assertEqual(StorageResponse.OK, response)
     StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
     response = self.wait()
     self.assertEqual(StorageResponse.OK, response)

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
 def test_add_thumbnail(self):
     collection_name = str(uuid.uuid1())
     StorageServer.add_collection(self.__account_id, collection_name, callback=self.stop)
     response = self.wait()
     self.assertEqual(StorageResponse.OK, response)
     thumbnail = open("../test_resources/thumbnail.jpg")
     StorageServer.add_thumbnail(self.__account_id, collection_name, thumbnail, callback=self.stop)
     response = self.wait()
     self.assertEqual(StorageResponse.OK, response)
     # cleanup
     StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
     self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_list_collections_valid_account(self):
        collection_name = str(uuid.uuid1())
        StorageServer.add_collection(self.__account_id, collection_name, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)
        StorageServer.list_collections(self.__account_id, callback=self.stop)
        collections = self.wait()
        self.assertTrue(len(collections) > 0)

        # cleanup
        StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_does_collection_exist(self):
        collection_name = str(uuid.uuid1())
        StorageServer.add_collection(self.__account_id, collection_name, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        StorageServer.does_collection_exist(self.__account_id, collection_name, callback=self.stop)
        response = self.wait()
        self.assertTrue(response)

        # cleanup
        StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_save_collection_manifest(self):
        collection_name = "dummy"
        StorageServer.add_collection(self.__account_id, collection_name, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)
        collection_file = open("../test_resources/collection.xml")
        StorageServer.save_collection_manifest(self.__account_id, collection_name, collection_file, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        # clean up
        StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
        self.wait()

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_collection [as 别名]
    def test_list_all_notes_empty_collection(self):

        collection_name = "dummy"
        StorageServer.add_collection(self.__account_id, collection_name, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        StorageServer.list_all_notes(self.__account_id, collection_name, callback=self.stop)
        response = self.wait()
        self.assertEqual(0, len(response))

        # clean up
        StorageServer.remove_collection(self.__account_id, collection_name, callback=self.stop)
        self.wait()