From 8a0e649f989a824bb3bbfd1900a5b8e5383b47e1 Mon Sep 17 00:00:00 2001
From: Harrison Healey <harrisonmhealey@gmail.com>
Date: Fri, 30 Sep 2016 11:06:30 -0400
Subject: PLT-3105 Files table migration (#4068)

* Implemented initial changes for files table

* Removed *_benchmark_test.go files

* Re-implemented GetPublicFile and added support for old path

* Localization for files table

* Moved file system code into utils package

* Finished server-side changes and added initial upgrade script

* Added getPostFiles api

* Re-add Extension and HasPreviewImage fields to FileInfo

* Removed unused translation

* Fixed merge conflicts left over after permissions changes

* Forced FileInfo.extension to be lower case

* Changed FileUploadResponse to contain the FileInfos instead of FileIds

* Fixed permissions on getFile* calls

* Fixed notifications for file uploads

* Added initial version of client code for files changes

* Permanently added FileIds field to Post object and removed Post.HasFiles

* Updated PostStore.Update to be usable in more circumstances

* Re-added Filenames field and switched file migration to be entirely lazy-loaded

* Increased max listener count for FileStore

* Removed unused fileInfoCache

* Moved file system code back into api

* Removed duplicate test case

* Fixed unit test running on ports other than 8065

* Renamed HasPermissionToPostContext to HasPermissionToChannelByPostContext

* Refactored handleImages to make it more easily understandable

* Renamed getPostFiles to getFileInfosForPost

* Re-added pre-FileIds posts to analytics

* Changed files to be saved as their ids as opposed to id/filename.ext

* Renamed FileInfo.UserId to FileInfo.CreatorId

* Fixed detection of language in CodePreview

* Fixed switching between threads in the RHS not loading new files

* Add serverside protection against a rare bug where the client sends the same file twice for a single post

* Refactored the important parts of uploadFile api call into a function that can be called without a web context
---
 webapp/tests/client_file.test.jsx | 248 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 248 insertions(+)
 create mode 100644 webapp/tests/client_file.test.jsx

(limited to 'webapp/tests/client_file.test.jsx')

diff --git a/webapp/tests/client_file.test.jsx b/webapp/tests/client_file.test.jsx
new file mode 100644
index 000000000..fac70d19c
--- /dev/null
+++ b/webapp/tests/client_file.test.jsx
@@ -0,0 +1,248 @@
+// Copyright (c) 2016 Mattermost, Inc. All Rights Reserved.
+// See License.txt for license information.
+
+import assert from 'assert';
+import TestHelper from './test_helper.jsx';
+
+const fs = require('fs');
+
+describe('Client.File', function() {
+    this.timeout(100000);
+
+    before(function() {
+        // write a temporary file so that we have something to upload for testing
+        const buffer = new Buffer('R0lGODlhAQABAIABAP///wAAACwAAAAAAQABAAACAkQBADs=', 'base64');
+
+        const testGif = fs.openSync('test.gif', 'w+');
+        fs.writeFileSync(testGif, buffer);
+    });
+
+    after(function() {
+        fs.unlinkSync('test.gif');
+    });
+
+    it('uploadFile', function(done) {
+        TestHelper.initBasic(() => {
+            const clientId = TestHelper.generateId();
+
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                clientId,
+                function(resp) {
+                    assert.equal(resp.file_infos.length, 1);
+                    assert.equal(resp.client_ids.length, 1);
+                    assert.equal(resp.client_ids[0], clientId);
+
+                    done();
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+
+    it('getFile', function(done) {
+        TestHelper.initBasic(() => {
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                '',
+                function(resp) {
+                    TestHelper.basicClient().getFile(
+                        resp.file_infos[0].id,
+                        function() {
+                            done();
+                        },
+                        function(err2) {
+                            done(new Error(err2.message));
+                        }
+                    );
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+
+    it('getFileThumbnail', function(done) {
+        TestHelper.initBasic(() => {
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                '',
+                function(resp) {
+                    TestHelper.basicClient().getFileThumbnail(
+                        resp.file_infos[0].id,
+                        function() {
+                            done();
+                        },
+                        function(err) {
+                            done(new Error(err.message));
+                        }
+                    );
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+
+    it('getFilePreview', function(done) {
+        TestHelper.initBasic(() => {
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                '',
+                function(resp) {
+                    TestHelper.basicClient().getFilePreview(
+                        resp.file_infos[0].id,
+                        function() {
+                            done();
+                        },
+                        function(err2) {
+                            done(new Error(err2.message));
+                        }
+                    );
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+
+    it('getFileInfo', function(done) {
+        TestHelper.initBasic(() => {
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                '',
+                function(resp) {
+                    const fileId = resp.file_infos[0].id;
+
+                    TestHelper.basicClient().getFileInfo(
+                        fileId,
+                        function(info) {
+                            assert.equal(info.id, fileId);
+                            assert.equal(info.name, 'test.gif');
+
+                            done();
+                        },
+                        function(err2) {
+                            done(new Error(err2.message));
+                        }
+                    );
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+
+    it('getPublicLink', function(done) {
+        TestHelper.initBasic(() => {
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                '',
+                function(resp) {
+                    const post = TestHelper.fakePost();
+                    post.channel_id = TestHelper.basicChannel().id;
+                    post.file_ids = resp.file_infos.map((info) => info.id);
+
+                    TestHelper.basicClient().createPost(
+                        post,
+                        function(data) {
+                            assert.deepEqual(data.file_ids, post.file_ids);
+
+                            TestHelper.basicClient().getPublicLink(
+                                post.file_ids[0],
+                                function() {
+                                    done(new Error('public links should be disabled by default'));
+
+                                    // request.
+                                    //     get(link).
+                                    //     end(TestHelper.basicChannel().handleResponse.bind(
+                                    //         this,
+                                    //         'getPublicLink',
+                                    //         function() {
+                                    //             done();
+                                    //         },
+                                    //         function(err4) {
+                                    //             done(new Error(err4.message));
+                                    //         }
+                                    //     ));
+                                },
+                                function() {
+                                    done();
+
+                                    // done(new Error(err3.message));
+                                }
+                            );
+                        },
+                        function(err2) {
+                            done(new Error(err2.message));
+                        }
+                    );
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+
+    it('getFileInfosForPost', function(done) {
+        TestHelper.initBasic(() => {
+            TestHelper.basicClient().uploadFile(
+                fs.createReadStream('test.gif'),
+                'test.gif',
+                TestHelper.basicChannel().id,
+                '',
+                function(resp) {
+                    const post = TestHelper.fakePost();
+                    post.channel_id = TestHelper.basicChannel().id;
+                    post.file_ids = resp.file_infos.map((info) => info.id);
+
+                    TestHelper.basicClient().createPost(
+                        post,
+                        function(data) {
+                            assert.deepEqual(data.file_ids, post.file_ids);
+
+                            TestHelper.basicClient().getFileInfosForPost(
+                                post.channel_id,
+                                data.id,
+                                function(files) {
+                                    assert.equal(files.length, 1);
+                                    assert.equal(files[0].id, resp.file_infos[0].id);
+
+                                    done();
+                                },
+                                function(err3) {
+                                    done(new Error(err3.message));
+                                }
+                            );
+                        },
+                        function(err2) {
+                            done(new Error(err2.message));
+                        }
+                    );
+                },
+                function(err) {
+                    done(new Error(err.message));
+                }
+            );
+        });
+    });
+});
-- 
cgit v1.2.3-1-g7c22

