Python StorageServer.add_note_to_collection方法代码示例

# 需要导入模块: from Storage.StorageServer import StorageServer [as 别名]
# 或者: from Storage.StorageServer.StorageServer import add_note_to_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_note_to_collection [as 别名]
    def test_add_note_to_collection_no_file(self):

        collection_name = "col_name"
        note_name = "noteName"
        StorageServer.add_note_to_collection(
            self.__account_id, collection_name, note_name, note_file=None, 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_note_to_collection [as 别名]
    def test_add_note_to_non_existing_collection(self):

        collection_name = "col_name"
        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()
        # Accepted
        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_note_to_collection [as 别名]
    def test_get_note(self):

        collection_name = "col_name"
        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)
        StorageServer.get_note_from_collection(self.__account_id, collection_name, note_name, callback=self.stop)
        response = self.wait()
        self.assertTrue(response is not None)

        # 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_note_to_collection [as 别名]
    def test_list_all_notes(self):

        collection_name = "col_name"
        note_name = "noteName"
        note_file = open("../test_resources/note.xml")
        for i in range(1, 5):
            new_note_name = note_name + str(i)
            StorageServer.add_note_to_collection(
                self.__account_id, collection_name, new_note_name, note_file, 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(4, len(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_note_to_collection [as 别名]
    def test_existance_of_note_img_invalid(self):
        # create collection and note without image
        collection_name = "col_name"
        note_name = "noteName"
        StorageServer.add_note_to_collection(
            self.__account_id, collection_name, note_name, note_file=None, callback=self.stop
        )
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        # check for existance
        StorageServer.does_note_resource_exist(
            self.__account_id, collection_name, note_name, StorageResourceType.NOTE_IMG, callback=self.stop
        )
        does_exist = self.wait()
        self.assertTrue(not does_exist)

        # 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_note_to_collection [as 别名]
    def test_add_note_img_to_collection(self):

        # create note
        collection_name = "col_name"
        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)

        # add image
        img_file = open("../test_resources/note_img.jpg")
        StorageServer.add_image_to_note(self.__account_id, collection_name, note_name, img_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_note_to_collection [as 别名]
    def test_existance_of_note_valid(self):
        collection_name = "col_name"
        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)

        # check the existance
        StorageServer.does_note_resource_exist(
            self.__account_id, collection_name, note_name, StorageResourceType.NOTE_MANIFEST, callback=self.stop
        )

        does_exist = self.wait()
        self.assertTrue(does_exist)

        # 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_note_to_collection [as 别名]
    def test_copy_collection_with_notes_between_accounts(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)
        note_name = "noteName"
        note_file = open("../test_resources/note.xml")
        StorageServer.add_note_to_collection(
            self.__account_id, first_collection_name, note_name, note_file, callback=self.stop
        )
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        second_collection_name = first_collection_name
        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)

        StorageServer.list_all_notes(self.__second_account_id, second_collection_name, callback=self.stop)
        note_list = self.wait()
        self.assertTrue(note_name in note_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_note_to_collection [as 别名]
    def test_remove_note(self):

        collection_name = "col_name"
        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)

        # remove
        StorageServer.remove_note(self.__account_id, collection_name, note_name, callback=self.stop)
        response = self.wait()
        self.assertEqual(StorageResponse.OK, response)

        # verify the delete
        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()