def test_delete(self):

        # first create a couple of files
        self.test_multiple_files()
        folder = self.portal['dropboxfolder']
        self.assertEqual(2, len(folder))

        processor = IDropboxSyncProcessor(folder)

        sync_data = {
                "entries": [
                    ['/Somewhere_over_the_rainbow.txt'.lower(), None],
                    ],
                "reset": False,
                "cursor": "3",
                "has_more": False,
                }
        self.client.delta_response.append(sync_data)
        processor.sync()
        self.assertEqual(1, len(folder))
        self.assertTrue('magnum-opus.txt' in folder)
        self.assertTrue(not 'somewhere_over_the_rainbow.txt' in folder)

        sync_data = {
                "entries": [
                    ['/magnum-opus.txt'.lower(), None],
                    ],
                "reset": False,
                "cursor": "3",
                "has_more": False,
                }
        self.client.delta_response.append(sync_data)
        processor.sync()
        self.assertEqual(0, len(folder))
    def test_delta_cursor_stored(self):
        container = self.portal

        metadata = json.loads("""
            {
               "bytes": 77,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/magnum-opus.txt",
               "rev": "362e2029684fe",
               "revision": 221922,
               "root": "dropbox",
               "size": "77 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
                "entries": [
                    ["/magnum-opus.txt", metadata],
                    ],
                "reset": False,
                "cursor": "1",
                "has_more": False,
                }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO())

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None and not container_fti.allowType(DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" % (DROPBOX_FOLDER_TYPE,))

        folder = createContentInContainer(
            container,
            DROPBOX_FOLDER_TYPE,
            checkConstraints=False,
            id="dropboxfolder",
        )

        processor = IDropboxSyncProcessor(folder)
        md = IDropboxSyncMetadata(folder)

        processor.sync()
        self.assertEqual("1", md.delta_cursor())

        sync_data = {
                "entries": [],
                "reset": False,
                "cursor": "3",
                "has_more": False,
                }
        self.client.delta_response.append(sync_data)
        processor.sync()
        self.assertEqual("3", md.delta_cursor())
Exemple #3
0
    def test_odd_filename(self):
        container = self.portal

        metadata = json.loads("""
            {
               "bytes": 77,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/A long and mysterious filename",
               "rev": "362e2029684fe",
               "revision": 221922,
               "root": "dropbox",
               "size": "77 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
            "entries": [
                ["/a-long-and-mysterious-filename".lower(), metadata],
            ],
            "reset": False,
            "cursor": "1",
            "has_more": False,
        }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO())

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None and not container_fti.allowType(
                DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" %
                             (DROPBOX_FOLDER_TYPE, ))

        ob = createContentInContainer(
            container,
            DROPBOX_FOLDER_TYPE,
            checkConstraints=False,
            id="dropboxfolder",
        )

        processor = IDropboxSyncProcessor(ob)
        processor.sync()

        self.assertEqual(1, len(ob))
        self.assertIsNotNone(ob.get("a-long-and-mysterious-filename", None))

        metadata = IDropboxFileMetadata(
            ob['a-long-and-mysterious-filename']).get()
        self.assertIsNotNone(metadata)
        self.assertEqual(77, metadata['bytes'])
        self.assertEqual('362e2029684fe', metadata['rev'])
    def test_odd_filename(self):
        container = self.portal

        metadata = json.loads("""
            {
               "bytes": 77,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/A long and mysterious filename",
               "rev": "362e2029684fe",
               "revision": 221922,
               "root": "dropbox",
               "size": "77 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
                "entries": [
                    ["/a-long-and-mysterious-filename".lower(), metadata],
                    ],
                "reset": False,
                "cursor": "1",
                "has_more": False,
                }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO())

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None and not container_fti.allowType(DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" % (DROPBOX_FOLDER_TYPE,))

        ob = createContentInContainer(container,
                                      DROPBOX_FOLDER_TYPE,
                                      checkConstraints=False,
                                      id="dropboxfolder",
                                      )

        processor = IDropboxSyncProcessor(ob)
        processor.sync()

        self.assertEqual(1, len(ob))
        self.assertIsNotNone(ob.get("a-long-and-mysterious-filename", None))

        metadata = IDropboxFileMetadata(ob['a-long-and-mysterious-filename']).get()
        self.assertIsNotNone(metadata)
        self.assertEqual(77, metadata['bytes'])
        self.assertEqual('362e2029684fe', metadata['rev'])
Exemple #5
0
    def test_delete(self):

        # first create a couple of files
        self.test_multiple_files()
        folder = self.portal['dropboxfolder']
        self.assertEqual(2, len(folder))

        processor = IDropboxSyncProcessor(folder)

        sync_data = {
            "entries": [
                ['/Somewhere_over_the_rainbow.txt'.lower(), None],
            ],
            "reset": False,
            "cursor": "3",
            "has_more": False,
        }
        self.client.delta_response.append(sync_data)
        processor.sync()
        self.assertEqual(1, len(folder))
        self.assertTrue('magnum-opus.txt' in folder)
        self.assertTrue(not 'somewhere_over_the_rainbow.txt' in folder)

        sync_data = {
            "entries": [
                ['/magnum-opus.txt'.lower(), None],
            ],
            "reset": False,
            "cursor": "3",
            "has_more": False,
        }
        self.client.delta_response.append(sync_data)
        processor.sync()
        self.assertEqual(0, len(folder))
Exemple #6
0
    def test_new_file(self):
        container = self.portal
        test_file_content = "Mary had a little lamb"

        metadata = json.loads("""
            {
               "bytes": 77,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/magnum-opus.txt",
               "rev": "362e2029684fe",
               "revision": 221922,
               "root": "dropbox",
               "size": "77 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
            "entries": [
                ["/magnum-opus.txt".lower(), metadata],
            ],
            "reset": False,
            "cursor": "1",
            "has_more": False,
        }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO(test_file_content))

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None \
               and not container_fti.allowType(DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" %
                             (DROPBOX_FOLDER_TYPE, ))

        folder = createContentInContainer(
            container,
            DROPBOX_FOLDER_TYPE,
            checkConstraints=False,
            id="dropboxfolder",
        )

        processor = IDropboxSyncProcessor(folder)
        processor.sync()

        self.assertEqual(1, len(folder))
        self.assertIsNotNone(folder.get("magnum-opus.txt", None))

        thefile = folder['magnum-opus.txt']
        metadata = IDropboxFileMetadata(thefile).get()
        self.assertIsNotNone(metadata)
        self.assertEqual(77, metadata['bytes'])
        self.assertEqual('362e2029684fe', metadata['rev'])

        self.assertTrue(IDropboxFile.providedBy(thefile))
        self.assertEqual(thefile.file_data.data, test_file_content)
Exemple #7
0
    def test_single_file_update(self):
        container = self.portal

        metadata1 = json.loads("""
            {
               "bytes": 1230,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/Somewhere_over_the_rainbow.txt",
               "rev": "362e",
               "revision": 221922,
               "root": "dropbox",
               "size": "1230 bytes",
               "thumb_exists": false
           }
        """)

        metadata2 = json.loads("""
            {
               "bytes": 1235,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/Somewhere_over_the_rainbow.txt",
               "rev": "362f",
               "revision": 221962,
               "root": "dropbox",
               "size": "1235 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
            "entries": [
                [metadata1['path'].lower(), metadata1],
                [metadata2['path'].lower(), metadata2],
            ],
            "reset":
            False,
            "cursor":
            "1",
            "has_more":
            False,
        }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO())
        self.client.get_file_response.append(StringIO())

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None and not container_fti.allowType(
                DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" %
                             (DROPBOX_FOLDER_TYPE, ))

        ob = createContentInContainer(
            container,
            DROPBOX_FOLDER_TYPE,
            checkConstraints=False,
            id="dropboxfolder",
        )

        processor = IDropboxSyncProcessor(ob)
        processor.sync()

        self.assertEqual(1, len(ob))

        self.assertIsNotNone(ob.get("somewhere_over_the_rainbow.txt", None))
        metadata = IDropboxFileMetadata(
            ob['somewhere_over_the_rainbow.txt']).get()
        self.assertIsNotNone(metadata)
        self.assertEqual(1235, metadata['bytes'])
        self.assertEqual('362f', metadata['rev'])
    def sync_now(self):
        syncer = IDropboxSyncProcessor(self.context)
        syncer.sync()

        IStatusMessage(self.request).addStatusMessage("Dropbox sync complete.")
        return self.request.response.redirect(self.context.absolute_url())
    def test_new_file(self):
        container = self.portal
        test_file_content = "Mary had a little lamb"

        metadata = json.loads("""
            {
               "bytes": 77,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/magnum-opus.txt",
               "rev": "362e2029684fe",
               "revision": 221922,
               "root": "dropbox",
               "size": "77 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
            "entries": [
                ["/magnum-opus.txt".lower(), metadata],
            ],
            "reset": False,
            "cursor": "1",
            "has_more": False,
        }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO(test_file_content))

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None \
               and not container_fti.allowType(DROPBOX_FOLDER_TYPE):
            raise ValueError(
                "Disallowed subobject type: %s" % (
                    DROPBOX_FOLDER_TYPE,))

        folder = createContentInContainer(container,
                                          DROPBOX_FOLDER_TYPE,
                                          checkConstraints=False,
                                          id="dropboxfolder",
                                          )

        processor = IDropboxSyncProcessor(folder)
        processor.sync()

        self.assertEqual(1, len(folder))
        self.assertIsNotNone(folder.get("magnum-opus.txt", None))

        thefile = folder['magnum-opus.txt']
        metadata = IDropboxFileMetadata(thefile).get()
        self.assertIsNotNone(metadata)
        self.assertEqual(77, metadata['bytes'])
        self.assertEqual('362e2029684fe', metadata['rev'])

        self.assertTrue(IDropboxFile.providedBy(thefile))
        self.assertEqual(thefile.file_data.data,
                         test_file_content)
    def test_single_file_update(self):
        container = self.portal

        metadata1 = json.loads("""
            {
               "bytes": 1230,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/Somewhere_over_the_rainbow.txt",
               "rev": "362e",
               "revision": 221922,
               "root": "dropbox",
               "size": "1230 bytes",
               "thumb_exists": false
           }
        """)

        metadata2 = json.loads("""
            {
               "bytes": 1235,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/Somewhere_over_the_rainbow.txt",
               "rev": "362f",
               "revision": 221962,
               "root": "dropbox",
               "size": "1235 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
                "entries": [
                    [metadata1['path'].lower(), metadata1],
                    [metadata2['path'].lower(), metadata2],
                    ],
                "reset": False,
                "cursor": "1",
                "has_more": False,
                }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO())
        self.client.get_file_response.append(StringIO())

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None and not container_fti.allowType(DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" % (DROPBOX_FOLDER_TYPE,))

        ob = createContentInContainer(container,
                                      DROPBOX_FOLDER_TYPE,
                                      checkConstraints=False,
                                      id="dropboxfolder",
                                      )

        processor = IDropboxSyncProcessor(ob)
        processor.sync()

        self.assertEqual(1, len(ob))

        self.assertIsNotNone(ob.get("somewhere_over_the_rainbow.txt", None))
        metadata = IDropboxFileMetadata(ob['somewhere_over_the_rainbow.txt']).get()
        self.assertIsNotNone(metadata)
        self.assertEqual(1235, metadata['bytes'])
        self.assertEqual('362f', metadata['rev'])
    def test_delta_cursor_stored(self):
        container = self.portal

        metadata = json.loads("""
            {
               "bytes": 77,
               "icon": "page_white_text",
               "is_dir": false,
               "mime_type": "text/plain",
               "modified": "Wed, 20 Jul 2011 22:04:50 +0000",
               "path": "/magnum-opus.txt",
               "rev": "362e2029684fe",
               "revision": 221922,
               "root": "dropbox",
               "size": "77 bytes",
               "thumb_exists": false
           }
        """)

        sync_data = {
            "entries": [
                ["/magnum-opus.txt", metadata],
            ],
            "reset": False,
            "cursor": "1",
            "has_more": False,
        }

        self.client.delta_response.append(sync_data)
        self.client.get_file_response.append(StringIO())

        container = self.portal
        container_fti = container.getTypeInfo()

        if container_fti is not None and not container_fti.allowType(
                DROPBOX_FOLDER_TYPE):
            raise ValueError("Disallowed subobject type: %s" %
                             (DROPBOX_FOLDER_TYPE, ))

        folder = createContentInContainer(
            container,
            DROPBOX_FOLDER_TYPE,
            checkConstraints=False,
            id="dropboxfolder",
        )

        processor = IDropboxSyncProcessor(folder)
        md = IDropboxSyncMetadata(folder)

        processor.sync()
        self.assertEqual("1", md.delta_cursor())

        sync_data = {
            "entries": [],
            "reset": False,
            "cursor": "3",
            "has_more": False,
        }
        self.client.delta_response.append(sync_data)
        processor.sync()
        self.assertEqual("3", md.delta_cursor())