Refactor FileUpload component and add unit tests for file upload functionality

Author: grantcopley

models/CBWIREController.cfc

@@ -139,7 +139,7 @@ component singleton {
         local.files = directoryList( path=local.storagePath, recurse=true, type="file", listInfo="query" );
         local.files.each( function( _file ) {
             if( dateDiff( "d", _file.DateLastModified, now() ) > 1 ){
-                fileDelete( _file );
+                fileDelete( _file.directory & "/" & _file.name );
             }
         } );
         // Verify the signed URL, throw 403 if invalid

models/FileUpload.cfc

@@ -1,131 +1,124 @@
-/** 
+/**
  * This is the file entity that is used to represent a file that has been uploaded
  * to the server. It is used to store the file in a temporary location and to
  * provide access to the file's metadata.
  */
 component {
 
-
     // Inject module settings
     property name="moduleSettings" inject="coldbox:modulesettings:cbwire";
 
     /**
      * Constructor
      */
     function load( wire, dataPropertyName, uuid ){
-        // Our CBWIRe Component
         variables.wire = arguments.wire;
-        // The data property name the file upload is for
-        variables.dataPropertyName = arguments.dataPropertyName; // getParams()[ 1 ]
-        // The UUID of the file upload we provided after the upload was complete
-        variables.uuid = arguments.uuid; // getParams()[ 2 ][ 1 ]
-        // The temp directory 
-        local.tempDirectory = getCanonicalPath( variables.moduleSettings.moduleRootPath & "models/tmp" );
-        // The file upload metadata JSON file path
-        variables.metaPath = getCanonicalPath( local.tempDirectory & "/#variables.uuid#.json" );
-        // Load the metadata, throw and exception if fails
-        if ( fileExists( variables.metaPath ) ) {
-            local.metaJSON = fileRead( variables.metaPath );
-            variables.meta = deserializeJSON( local.metaJSON );
+        variables.dataPropertyName = arguments.dataPropertyName;
+        variables.uuid = arguments.uuid;
+
+        var metaPath = getMetaPath();
+
+        if ( fileExists( metaPath ) ) {
+            var metaJSON = fileRead( metaPath );
+            variables.meta = deserializeJSON( metaJSON );
         } else {
             throw( type="CBWIREException", message="File upload metadata not found." );
         }
-        // The file upload temporary storage path
+
         variables.temporaryStoragePath = getCanonicalPath( variables.meta.serverDirectory & "/#variables.meta.serverFile#" );
-        // Return fileupload
         return this;
     }
 
     /**
      * Returns the base64 representation of the file
-     * 
-     * @return string
      */
     function getBase64(){
         return toBase64( get() );
     }
 
-    /** 
+    /**
      * Returns the base64 src of the file
-     * 
-     * @return string
      */
     function getBase64Src(){
         return "data:#getMimeType()#;base64, #getBase64()#";
     }
 
-    /** 
-     * Returns the binary for the uploaded file.
-     * 
-     * @return binary
+    /**
+     * Returns the binary for the uploaded file
      */
     function get(){
         return fileReadBinary( variables.temporaryStoragePath );
     }
 
     /**
-     * Returns the file's size.
-     * 
-     * @return numeric
+     * Returns the file's size
      */
     function getSize(){
         return variables.meta.fileSize;
     }
 
-    /** 
-     * Returns the file's MIME type.
-     * 
-     * @return string
+    /**
+     * Returns the file's MIME type
      */
     function getMIMEType(){
         return variables.meta.contentType & "/" & variables.meta.contentSubType;
     }
 
-    /** 
-     * Returns true if the uploaded file is an image. 
-     * 
-     * @return boolean
+    /**
+     * Returns true if the uploaded file is an image
      */
     function isImage(){
         return variables.meta.contentType == "image";
     }
 
-    /** 
-     * Returns the file's preview URL.
-     * 
-     * @return string
+    /**
+     * Returns the file's preview URL
      */
     function getPreviewURL(){
         return "/cbwire/preview-file/#variables.uuid#";
     }
 
     /**
      * Returns the temporary file path
-     *
-     * @return string
      */
     function getTemporaryStoragePath(){
-      return variables.temporaryStoragePath;
+        return variables.temporaryStoragePath;
     }
 
-    /** 
-     * Deletes the file in temporary storage and the metadata file.
-     * 
-     * @return void
+    /**
+     * Deletes the file in temporary storage and the metadata file
      */
     function destroy(){
         fileDelete( variables.temporaryStoragePath );
-        fileDelete( variables.metaPath );
+        fileDelete( getMetaPath() );
         variables.wire.reset( variables.dataPropertyName );
     }
 
-
-    /* 
+    /**
      * Serialize the file upload
-     * 
-     * @return string
      */
-    function serializeIt() {
+    function serializeIt(){
         return "fileupload:" & variables.uuid;
     }
-}
+
+    /**
+     * Return the meta data for the upload
+     */
+    function getMeta(){
+        return variables.meta;
+    }
+
+    /**
+     * Returns the path to the temp directory (mockable in tests)
+     */
+    function getTempDirectory(){
+        return getCanonicalPath( variables.moduleSettings.moduleRootPath & "models/tmp" );
+    }
+
+    /**
+     * Returns the full path to the metadata file (mockable in tests)
+     */
+    function getMetaPath(){
+        return getCanonicalPath( getTempDirectory() & "/#variables.uuid#.json" );
+    }
+}

test-harness/tests/resources/fileupload_metadata.json

@@ -0,0 +1 @@
+{"uuid":"test","fileSize":1234,"contentType":"text","contentSubType":"plain","serverDirectory":"/Users/grantcopley/Code/ortus/cbwire/cbwire/test-harness/tests/resources","serverFile":"logo.png"}

test-harness/tests/resources/logo.png

@@ -0,0 +1,134 @@
+component extends="coldbox.system.testing.BaseTestCase" {
+
+    function beforeAll() {
+        super.beforeAll();
+
+        // Clean out tmp directory before all tests
+        local.tempFolder = expandPath( "../../../models/tmp" );
+        if ( directoryExists( local.tempFolder ) ) {
+            directoryDelete( local.tempFolder, true );
+        }
+        directoryCreate( local.tempFolder );
+
+        // Ensure /resources exists
+        local.resourcePath = expandPath( "../resources" );
+        if ( !directoryExists( local.resourcePath ) ) {
+            directoryCreate( local.resourcePath );
+        }
+    }
+
+    function run( testResults, testBox ) {
+        describe( "FileUpload.cfc", function() {
+
+            beforeEach( function( currentSpec ) {
+                setup();
+
+                testComponent = getInstance( "wires.TestComponent" );
+                testComponent
+                    ._withEvent( getRequestContext() )
+                    ._withPath( "wires.TestComponent" );
+
+                prepareMock( testComponent );
+
+                fileUpload = getInstance( "FileUpload@cbwire" );
+                prepareMock( fileUpload );
+            });
+
+            it( "should return an object", function() {
+                var result = getInstance( "FileUpload@cbwire" );
+                expect( isObject( result ) ).toBeTrue();
+            });
+
+            it( "should load without error", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( isObject( result ) ).toBeTrue();
+            });
+
+            it( "should return the meta data", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.getMeta().uuid ).toBe( "test" );
+            });
+
+            it( "should return fileupload: uuid on serializeIt", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.serializeIt() ).toBe( "fileupload:test" );
+            });
+
+            it( "should return expected preview URL", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.getPreviewURL() ).toBe( "/cbwire/preview-file/test" );
+            });
+
+            it( "should determine is image", function() {
+                var result = loadMockedFileUpload( "test", "image", "png" );
+                expect( result.isImage() ).toBeTrue();
+            });
+
+            it( "should determine is NOT image", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.isImage() ).toBeFalse();
+            });
+
+            it( "should return the file size", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.getSize() ).toBe( 1234 );
+            });
+
+            it( "should return the MIME type", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.getMIMEType() ).toBe( "text/plain" );
+            });
+
+            it( "should return the temporary storage path", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.getTemporaryStoragePath() ).toBe( expandPath( "../resources/logo.png" ) );
+            });
+
+            it( "should return binary file contents when calling get", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( isBinary( result.get() ) ).toBeTrue();
+            });
+
+            it ( "should return base 64 encoded string when calling getBase64", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( isBinary( toBinary( result.getBase64() ) ) ).toBeTrue();
+            });
+
+            it( "should return base 64 src attribute contents when calling getBase64Src", function() {
+                var result = loadMockedFileUpload( "test", "text", "plain" );
+                expect( result.getBase64Src() ).toInclude( "data:" );
+            });
+
+        });
+    }
+
+    private function writeTestMetaFile( required path, required struct data ) {
+        if ( fileExists( arguments.path ) ) {
+            fileDelete( arguments.path );
+        }
+        fileWrite( arguments.path, serializeJSON( arguments.data ) );
+    }
+
+    private function loadMockedFileUpload(
+        required string uuid,
+        required string contentType,
+        required string contentSubType
+    ) {
+        var metaPath = expandPath( "../resources/fileupload_metadata.json" );
+
+        writeTestMetaFile(
+            path = metaPath,
+            data = {
+                "uuid" : arguments.uuid,
+                "serverDirectory" : expandPath( "../resources" ),
+                "serverFile" : "logo.png",
+                "contentType" : arguments.contentType,
+                "contentSubType" : arguments.contentSubType,
+                "fileSize" : 1234
+            }
+        );
+
+        fileUpload.$( "getMetaPath", metaPath );
+        return fileUpload.load( testComponent, "test", arguments.uuid );
+    }
+}