def test__upload__download__DownloadedFileShouldMatchOriginalUploaded(
            self):
        chunkCb = unittest.mock.Mock()

        with tempfile.NamedTemporaryFile('wb') as tf:
            tf.write(self.DATA)
            tf.flush()
            uploadSourceFileName = tf.name
            remoteName = basename(tf.name)
            elfcloudclient.upload(VALID_PARENTID, remoteName,
                                  uploadSourceFileName, chunkCb)
            EXPECTED_CB_PARAMS = [
                call(len(self.DATA), i_) for i_ in self.EXPECTED_CHUNKS
            ]
            chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)

            with tempfile.NamedTemporaryFile('wb') as tf:
                downloadSourceFileName = tf.name
                elfcloudclient.download(VALID_PARENTID,
                                        remoteName,
                                        downloadSourceFileName,
                                        key=None,
                                        chunkCb=chunkCb)
                self.assertTrue(
                    filecmp.cmp(uploadSourceFileName,
                                downloadSourceFileName,
                                shallow=False))
                chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)
    def test__upload__UseCancelCbToSplitUploadMultipleTimesUsingAppendMode_ShouldUploadCorrectly(self):
        CANCELCB_RETURN_VALUES = [False, True, False, False, False]
        currentOffset = 0
        currentRound = 0
        chunkCb = unittest.mock.Mock()

        def cancelCb(completed):
            nonlocal currentOffset, currentRound, CANCELCB_RETURN_VALUES
            rv = CANCELCB_RETURN_VALUES[currentRound]
            currentOffset = completed
            currentRound += 1
            return rv
 

        with tempfile.NamedTemporaryFile('wb', delete=False) as tf:
            tf.write(self.DATA)
            tf.flush()
            uploadSourceFileName = tf.name
            remoteName = basename(tf.name)
        
            while currentOffset < len(self.DATA):
                elfcloudclient.upload(VALID_PARENTID, remoteName, uploadSourceFileName, chunkCb, cancelCb, currentOffset)
            
            EXPECTED_CB_PARAMS = [call(len(self.DATA),i_) for i_ in self.EXPECTED_CHUNKS]
            chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)
            
            with tempfile.NamedTemporaryFile('wb', delete=False) as tf:
                downloadSourceFileName = tf.name
                elfcloudclient.download(VALID_PARENTID, remoteName, downloadSourceFileName, key=None, chunkCb=chunkCb)
                self.assertTrue(filecmp.cmp(uploadSourceFileName, downloadSourceFileName, shallow=False))
                chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)
def createRemoteTempFile():
    DATA = bytes(range(256))
    with tempfile.NamedTemporaryFile('wb') as tf:
        tf.write(DATA)
        tf.flush()
        dataItemName = basename(tf.name)
        elfcloudclient.upload(VALID_PARENTID, dataItemName, tf.name)
        yield dataItemName
def createRemoteTempFile():
    DATA = bytes(range(256))
    with tempfile.NamedTemporaryFile('wb') as tf:
        tf.write(DATA)
        tf.flush()
        dataItemName = basename(tf.name)
        elfcloudclient.upload(VALID_PARENTID, dataItemName, tf.name)
        yield dataItemName
Esempio n. 5
0
 def _handleUploadTask(self, task):
     try:
         elfcloudclient.upload(task.remoteParentId, task.remoteName, task.localPath, task.chunkCb,
                               lambda totalUploadedSize : self.__cancelCb(task, totalUploadedSize),
                               task.uploadedSize if task.uploadedSize else None)
         self._submitUploadTaskDone(task)
     except elfcloudclient.ClientException as e:
         logger.error("Upload exception: %s" % str(e))
         self._submitUploadTaskFailed(task, e)
Esempio n. 6
0
def uploadTestFile(data):
    """Uploads a testfile to cloud with given content."""

    with tempfile.NamedTemporaryFile('wb') as tf:
        tf.write(data)
        tf.flush()
        remoteName = basename(tf.name)
        elfcloudclient.upload(VALID_PARENTID, remoteName, tf.name)
        yield (tf.name, remoteName)
        elfcloudclient.removeDataItem(VALID_PARENTID, remoteName)
Esempio n. 7
0
 def _handleUploadTask(self, task):
     try:
         elfcloudclient.upload(
             task.remoteParentId, task.remoteName, task.localPath,
             task.chunkCb, lambda totalUploadedSize: self.__cancelCb(
                 task, totalUploadedSize),
             task.uploadedSize if task.uploadedSize else None)
         self._submitUploadTaskDone(task)
     except elfcloudclient.ClientException as e:
         logger.error("Upload exception: %s" % str(e))
         self._submitUploadTaskFailed(task, e)
 def test_upload_ShouldAllowReadingInChunks_ShouldCallCbPerChunk(self, mock_getsize, mock_open, mock_client):
     mock_open.return_value.read=io.StringIO(Test_elfcloudclient.TEST_DATA).read
     mock_getsize.return_value = Test_elfcloudclient.TEST_DATA_SIZE
     mock_client.store_data.side_effect = Test_elfcloudclient._store_data_SideEffect
     mock_cb = unittest.mock.Mock()
 
     elfcloudclient.upload(123, "remotename", "filename", mock_cb)
     mock_getsize.assert_called_once_with("filename")
     mock_open.assert_called_once_with("filename", "rb")
     
     EXPECTED_CB_PARAMS = [call(Test_elfcloudclient.TEST_DATA_SIZE,i) for i in Test_elfcloudclient.EXPECTED_TOTAL_READ_IN_CHUNKS]
     mock_cb.assert_has_calls(EXPECTED_CB_PARAMS)
 def test__upload__download__DownloadedFileShouldMatchOriginalUploaded(self):
     chunkCb = unittest.mock.Mock()
     with tempfile.NamedTemporaryFile('wb') as tf:
         tf.write(self.DATA)
         tf.flush()
         uploadSourceFileName = tf.name
         remoteName = basename(tf.name)
         elfcloudclient.upload(VALID_PARENTID, remoteName, uploadSourceFileName, chunkCb)
         EXPECTED_CB_PARAMS = [call(len(self.DATA),i_) for i_ in self.EXPECTED_CHUNKS]
         chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)
         
         with tempfile.NamedTemporaryFile('wb') as tf:
             downloadSourceFileName = tf.name
             elfcloudclient.download(VALID_PARENTID, remoteName, downloadSourceFileName, key=None, chunkCb=chunkCb)
             self.assertTrue(filecmp.cmp(uploadSourceFileName, downloadSourceFileName, shallow=False))
             chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)
Esempio n. 10
0
    def test_upload_ShouldAllowReadingInChunks_ShouldCallCbPerChunk(
            self, mock_getsize, mock_open, mock_client):
        mock_open.return_value.read = io.StringIO(
            Test_elfcloudclient.TEST_DATA).read
        mock_getsize.return_value = Test_elfcloudclient.TEST_DATA_SIZE
        mock_client.store_data.side_effect = Test_elfcloudclient._store_data_SideEffect
        mock_cb = unittest.mock.Mock()

        elfcloudclient.upload(123, "remotename", "filename", mock_cb)
        mock_getsize.assert_called_once_with("filename")
        mock_open.assert_called_once_with("filename", "rb")

        EXPECTED_CB_PARAMS = [
            call(Test_elfcloudclient.TEST_DATA_SIZE, i)
            for i in Test_elfcloudclient.EXPECTED_TOTAL_READ_IN_CHUNKS
        ]
        mock_cb.assert_has_calls(EXPECTED_CB_PARAMS)
    def test__upload__UseCancelCbToSplitUploadMultipleTimesUsingAppendMode_ShouldUploadCorrectly(
            self):
        CANCELCB_RETURN_VALUES = [False, True, False, False, False]
        currentOffset = 0
        currentRound = 0
        chunkCb = unittest.mock.Mock()

        def cancelCb(completed):
            nonlocal currentOffset, currentRound, CANCELCB_RETURN_VALUES
            rv = CANCELCB_RETURN_VALUES[currentRound]
            currentOffset = completed
            currentRound += 1
            return rv

        with tempfile.NamedTemporaryFile('wb', delete=False) as tf:
            tf.write(self.DATA)
            tf.flush()
            uploadSourceFileName = tf.name
            remoteName = basename(tf.name)

            while currentOffset < len(self.DATA):
                elfcloudclient.upload(VALID_PARENTID, remoteName,
                                      uploadSourceFileName, chunkCb, cancelCb,
                                      currentOffset)

            EXPECTED_CB_PARAMS = [
                call(len(self.DATA), i_) for i_ in self.EXPECTED_CHUNKS
            ]
            chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)

            with tempfile.NamedTemporaryFile('wb', delete=False) as tf:
                downloadSourceFileName = tf.name
                elfcloudclient.download(VALID_PARENTID,
                                        remoteName,
                                        downloadSourceFileName,
                                        key=None,
                                        chunkCb=chunkCb)
                self.assertTrue(
                    filecmp.cmp(uploadSourceFileName,
                                downloadSourceFileName,
                                shallow=False))
                chunkCb.assert_has_calls(EXPECTED_CB_PARAMS)