grip 0.5.1 → 0.6.0

data/README.rdoc

@@ -6,34 +6,42 @@ GridFS attachments for MongoMapper
 
 The grip gem is hosted on gemcutter.org:
 
-* gem install grip
+    gem install miso grip
 
 
-= Usage
+= Usage (See tests for better docs)
 
-    class Foo
+    class Doc
       include MongoMapper::Document
       include Grip
 
       has_grid_attachment :image, :versions => {:thumb => {:width=>50,:height=>50}}
-      has_grid_attachment :pdf
       
-      # Hook for resizing or whatever gets you there.
-      # any specified options are passed back to you
-      # at this point. 
-      # Just return the file when you're done.
-      def process_image opts
-        puts "processing"
-        opts[:file]
-      end
     end
 
     image = File.open('foo.png', 'r')
-    pdf = File.open('foo.pdf', 'r')
-    foo = Foo.create(:image => image, :pdf => pdf)
-
-    foo.image # contents read from gridfs for serving from rack/metal/controller
-    foo.image_name # foo.jpg
-    foo.image_content_type # image/png
-    foo.image_size # File.size of the file
-    foo.image_path # path in grid fs foo/image/:id where :id is foo.id
+    @doc = Doc.create(:image => image)
+
+    puts @doc.image.name 
+    => "image"
+    puts @doc.image.file_size
+    => 100
+    puts @doc.image.file_name
+    => "foo.png"
+    puts @doc.image.grid_key
+    => "docs/<id>/image"
+    
+    # works on nested variants as well
+    
+    puts @doc.image.thumb.name 
+    => "thumb"
+    puts @doc.image.thumb.file_size
+    => 50
+    puts @doc.image.thumb.file_name
+    => "foo.png"
+    puts @doc.image.thumb.grid_key
+    => "attachments/<id>/thumb"
+    
+    
+    @doc.image.file # contents read from gridfs for serving from rack/metal/controller 
+

data/VERSION

@@ -1 +1 @@
-0.5.1
+0.6.0

data/grip.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{grip}
-  s.version = "0.5.1"
+  s.version = "0.6.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["twoism", "jnunemaker"]
-  s.date = %q{2009-12-30}
+  s.date = %q{2009-12-31}
   s.description = %q{GridFS attachments for MongoMapper}
   s.email = %q{signalstatic@gmail.com}
   s.extra_rdoc_files = [
@@ -17,16 +17,23 @@ Gem::Specification.new do |s|
      "README.rdoc"
   ]
   s.files = [
-    ".gitignore",
+    ".DS_Store",
+     ".gitignore",
      "LICENSE",
      "README.rdoc",
      "Rakefile",
      "VERSION",
      "grip.gemspec",
      "lib/grip.rb",
+     "lib/grip/attachment.rb",
+     "lib/grip/has_attachment.rb",
+     "test/factories.rb",
      "test/fixtures/cthulhu.png",
      "test/fixtures/sample.pdf",
-     "test/test_grip.rb",
+     "test/growler.rb",
+     "test/models.rb",
+     "test/test_grip_attachment.rb",
+     "test/test_has_attachment.rb",
      "test/test_helper.rb"
   ]
   s.homepage = %q{http://github.com/twoism/grip}
@@ -35,7 +42,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.5}
   s.summary = %q{GridFS attachments for MongoMapper}
   s.test_files = [
-    "test/test_grip.rb",
+    "test/factories.rb",
+     "test/growler.rb",
+     "test/models.rb",
+     "test/test_grip_attachment.rb",
+     "test/test_has_attachment.rb",
      "test/test_helper.rb"
   ]
 

data/lib/grip.rb

@@ -1,125 +1,10 @@
-require 'mongo/gridfs'
-require 'mime/types'
-require 'tempfile'
-require 'miso'
+%w{mongo_mapper mongo/gridfs mime/types ftools tempfile rmagick miso}.each { |lib| require lib }
 
-module Grip
-  def self.included(base)
-    base.extend Grip::ClassMethods
-    base.class_eval do
-      after_save      :save_attachments
-      before_destroy  :destroy_attached_files
-    end
+module MongoMapper
+  module Grip
+    class GripError < StandardError;  end
+    class InvalidFile < GripError;  end
   end
-  
-  module ClassMethods
-    def has_grid_attachment(name,opts={})
-      write_inheritable_attribute(:attachment_definitions, {}) if attachment_definitions.nil?
-      attachment_definitions[name] = opts
-      
-      build_attachment_keys_for name
-      
-      define_method(name) do
-        GridFS::GridStore.open(self.class.database, self["#{name}_path"], 'r') {|f| f }
-      end
-      
-      define_method("#{name}=") do |file|
-        update_attachment_attributes!(name, file)
-        self.class.attachment_definitions[name][:file] = file
-      end
-      
-      unless opts[:versions].nil?
-        opts[:versions].each do |v,dimensions|
-
-          version_name = "#{name}_#{v}"
-          build_attachment_keys_for version_name
-          
-          define_method(version_name) do
-            GridFS::GridStore.open(self.class.database, self["#{version_name}_path"], 'r') {|f| f }
-          end
-
-          define_method("#{version_name}=") do |file|
-            update_attachment_attributes!("#{version_name}", file, true)
-            self["#{version_name}_content_type"] = self["#{name}_content_type"]
-          end
-        end
-      end
-    end
-    
-    def build_attachment_keys_for name
-      key "#{name}_size".to_sym, Integer
-      key "#{name}_path".to_sym, String
-      key "#{name}_name".to_sym, String
-      key "#{name}_content_type".to_sym, String
-    end
-    
-    def attachment_definitions
-      read_inheritable_attribute(:attachment_definitions)
-    end
-  end
-  
-  def update_attachment_attributes! name, file, is_version = false
-    raise Grip::InvalidFileException unless (file.is_a?(File) || file.is_a?(Tempfile) || file.is_a?(Miso::Image))
-    
-    self["#{name}_size"]         = File.size(file) 
-    self["#{name}_name"]         = File.basename(file.path)
-    
-    unless is_version
-      self['_id']                  = Mongo::ObjectID.new if _id.blank?
-      self["#{name}_content_type"] = file.content_type rescue MIME::Types.type_for(self["#{name}_name"]).to_s
-      self["#{name}_path"]         = "#{self.class.to_s.underscore}/#{name}/#{_id}"
-    else
-      self["#{name}_path"]         = "#{self.class.to_s.underscore}/#{name}/#{_id}"
-    end
-  end
-  
-  # Roll through attachment definitions and check if they are a File or Tempfile. Both types are 
-  # nescessary for file uploads to work properly. Each file checks for a <attr_name>_process
-  # callback for pre-processing before save.
-  def save_attachments
-    self.class.attachment_definitions.each do |definition|
-      attr_name, opts = definition
-      
-      GridFS::GridStore.open(self.class.database, self["#{attr_name}_path"], 'w', :content_type => self["#{attr_name}_content_type"]) do |f|
-        f.write opts[:file].read
-      end
-      
-      unless opts[:versions].nil?
-        opts[:versions].each do |version,dimensions|
-          
-          tmp   = Tempfile.new("#{attr_name}_#{version}")
-          image = Miso::Image.new(opts[:file].path)
-          
-          image.crop(dimensions[:width], dimensions[:height])  if opts[:crop]
-          image.fit(dimensions[:width], dimensions[:height])   unless opts[:crop]
-          
-          image.write(tmp.path)
-          
-          # update <name>_<version> attrs and assign the file
-          send("#{attr_name}_#{version}=", tmp)
-          
-          GridFS::GridStore.open(self.class.database, self["#{attr_name}_#{version}_path"], 'w', :content_type => self["#{attr_name}_content_type"]) do |f|
-            f.write tmp.read
-          end
-          
-        end
-        save_to_collection
-      end
-    end unless self.class.attachment_definitions.nil?
-  end
-  
-  def destroy_attached_files
-    self.class.attachment_definitions.each do |name, attachment|
-      GridFS::GridStore.unlink(self.class.database, self["#{name}_path"])
-      unless attachment[:versions].nil?
-        attachment[:versions].each do |v,dim|
-          GridFS::GridStore.unlink(self.class.database, self["#{name}_#{v}_path"])
-        end
-      end
-    end unless self.class.attachment_definitions.nil?
-  end
-  
-  class Grip::InvalidFileException < Exception
-  end
-  
 end
+
+%w{grip/attachment grip/has_attachment}.each { |lib| require lib }

data/lib/grip/attachment.rb

@@ -0,0 +1,84 @@
+module MongoMapper
+  module Grip
+    class Attachment
+      include MongoMapper::Document
+
+      belongs_to :owner, :polymorphic => true
+      many :attached_variants, :as => :owner, :class_name => "MongoMapper::Grip::Attachment", :dependent => :destroy
+            
+      key :owner_id,      ObjectId, :required => true
+      key :owner_type,    String,   :required => true
+
+      key :name,          String
+      key :file_name,     String
+      key :file_size,     Integer
+      key :content_type,  String
+      key :variants,      Hash
+      
+      after_save :build_variants
+      
+      def file=new_file
+        raise InvalidFile unless (new_file.is_a?(File) || new_file.is_a?(Tempfile))
+        
+        self.file_name    = File.basename(new_file.path)
+        self.file_size    = File.size(new_file.path)
+        self.content_type = MIME::Types.type_for(new_file.path)
+        
+        write_to_grid new_file
+      end
+      
+      def file
+        read_from_grid grid_key
+      end
+      
+      def grid_key
+        "#{owner_type.pluralize}/#{owner_id}/#{name}".downcase
+      end
+      
+      def self.create_method sym, &block
+        define_method sym do |*block.args|
+          yield
+        end
+      end
+      
+      private
+        def build_variants
+          self.variants.each do |variant, dimensions|
+            
+            eval <<-EOF
+              def #{variant}
+                Attachment.find_or_initialize_by_name_and_owner_id("#{variant.to_s}",self._id)
+              end
+            EOF
+            
+            eval <<-EOF
+              def #{variant}=(file_hash)
+                new_attachment  = Attachment.find_or_initialize_by_name_and_owner_id("#{variant.to_s}",self._id)
+                new_attachment.owner_type   = self.class.to_s
+                new_attachment.file_name    = File.basename(file_hash[:uploaded_file].path)
+                new_attachment.file_size    = File.size(file_hash[:resized_file].path)
+                new_attachment.content_type = MIME::Types.type_for(file_hash[:uploaded_file].path)
+                new_attachment.save!
+
+                GridFS::GridStore.open(self.class.database, new_attachment.grid_key, 'w', :content_type => new_attachment.content_type) do |f|
+                  f.write file_hash[:resized_file].read
+                end
+
+              end
+            EOF
+            
+          end
+        end
+      
+        def write_to_grid new_file
+          GridFS::GridStore.open(self.class.database, grid_key, 'w', :content_type => content_type) do |f|
+            f.write new_file.read
+          end
+        end
+        
+        def read_from_grid key
+          GridFS::GridStore.open(self.class.database, key, 'r') { |f| f }
+        end
+    end
+  end
+end

data/lib/grip/has_attachment.rb

@@ -0,0 +1,75 @@
+module MongoMapper
+  module Grip
+   module HasAttachment
+      module ClassMethods
+        
+        def has_grid_attachment name, opts={}
+          write_inheritable_attribute(:uploaded_files, {}) if uploaded_files.nil?
+          uploaded_files[name] = opts
+          
+          define_method(name) do
+            attachments.find(:first,:conditions=>{:name=>name.to_s})
+          end
+
+          define_method("#{name}=") do |new_file| 
+            raise InvalidFile unless (new_file.is_a?(File) || new_file.is_a?(Tempfile))
+
+            self['_id']     = Mongo::ObjectID.new if _id.blank?
+            new_attachment  = Attachment.find_or_initialize_by_name_and_owner_id(name.to_s,self._id)
+            update_attachment_attributes!(new_attachment, new_file, opts)
+            self.class.uploaded_files[name][:file] = new_file
+          end
+                    
+        end
+        
+        def uploaded_files
+          read_inheritable_attribute(:uploaded_files)
+        end
+        
+      end
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          after_save      :save_attachments
+          before_destroy  :destroy_attached_files
+          
+          many :attachments, :as => :owner, :class_name => "MongoMapper::Grip::Attachment", :dependent => :destroy
+        end
+      end
+      
+      def update_attachment_attributes! new_attachment, new_file, opts
+        new_attachment.owner_type   = self.class.to_s
+        new_attachment.file_name    = File.basename(new_file.path)
+        new_attachment.file_size    = File.size(new_file.path)
+        new_attachment.content_type = MIME::Types.type_for(new_file.path)
+        new_attachment.file         = new_file
+        new_attachment.variants     = opts[:variants] || {}
+        new_attachment.save!
+      end
+      
+      def save_attachments
+        attachments.each do |attachment|
+          attachment.variants.each do |variant,dimensions|
+            create_variant(attachment,variant,dimensions)
+          end
+        end
+      end
+      
+      def create_variant attachment, variant, dimensions
+        tmp_file = self.class.uploaded_files[attachment.name.to_sym][:file]
+        tmp   = Tempfile.new("#{attachment.name}_#{variant}")
+        image = Miso::Image.new(tmp_file.path)
+        
+        image.crop(dimensions[:width], dimensions[:height])  if dimensions[:crop]
+        image.fit(dimensions[:width], dimensions[:height])   unless dimensions[:crop]
+        
+        image.write(tmp.path)
+        
+        file_hash = {:resized_file => tmp,:uploaded_file => tmp_file} 
+        
+        attachment.send("#{variant}=", file_hash)
+      end
+      
+    end
+  end
+end

data/test/factories.rb

@@ -0,0 +1,11 @@
+require "mongo_mapper"
+variants = { :thumb => {:width=>50,:height=>50} }
+Factory.define :attachment do |a|
+  a.owner_id Mongo::ObjectID.new
+  a.owner_type  'Mock'
+  a.name 'image'
+  a.file_name 'mock.png'
+  a.file_size 100
+  a.content_type 'image/png'
+  a.variants variants
+end

data/test/growler.rb

@@ -0,0 +1,9 @@
+require 'ruby-growl'
+class Growler
+  def self.growl msg
+    g = Growl.new "localhost", "ruby-growl",
+                  ["ruby-growl Notification"]
+    g.notify "ruby-growl Notification", ":::: From Rails ::::::::",
+             "#{msg}",1,true
+  end
+end

data/test/models.rb

@@ -0,0 +1,5 @@
+class Doc
+  include MongoMapper::Document
+  include MongoMapper::Grip::HasAttachment
+  has_grid_attachment :image, :variants => {:thumb=>{:width=>50,:height=>50},:super_thumb=>{:width=>10,:height=>10}}
+end

data/test/test_grip_attachment.rb

@@ -0,0 +1,64 @@
+require "test_helper"
+
+include MongoMapper::Grip
+
+class GripAttachmentTest < Test::Unit::TestCase
+  context "An Attachment" do
+    setup do
+      @attachment   = Attachment.new( :name => "image", :owner_type => "Mock", :owner_id => Mongo::ObjectID.new )
+      @dir          = File.dirname(__FILE__) + '/fixtures'
+      @image        = File.open("#{@dir}/cthulhu.png", 'r')
+      @file_system  = MongoMapper.database['fs.files']
+    end
+    
+    teardown do
+      @file_system.drop
+      @image.close
+    end
+
+    should "be an Attachment" do
+      assert @attachment.is_a?(Attachment)
+    end
+    
+    should "belong to :owner" do
+      name,assoc = Attachment.associations.first
+      #assert_equal(:owner, assoc.name)
+      #assert_equal(:belongs_to, assoc.type)
+    end
+    
+    context "with a valid file" do
+      setup do
+        @attachment.file = @image
+      end
+
+      should "have correct :content_type" do
+        assert_equal("image/png", @attachment.content_type)
+      end
+      
+      should "have correct :file_size" do
+        assert_equal(27582, @attachment.file_size)
+      end
+      
+      should "have correct :file_name" do
+        assert_equal("cthulhu.png", @attachment.file_name)
+      end
+      
+      should "read file from grid store" do
+        assert_equal "image/png", @file_system.find_one(:filename => @attachment.grid_key)['contentType']
+      end
+      
+      should "return a GridStore" do
+        assert_equal(GridFS::GridStore, @attachment.file.class)
+      end
+      
+    end
+    
+    context "with an invalid file" do
+      should "raise Grip::InvalidFile" do
+        assert_raise(InvalidFile) { @attachment.file = Hash.new }
+      end
+    end
+
+  end
+    
+end

data/test/test_has_attachment.rb

@@ -0,0 +1,68 @@
+require "test_helper"
+require "models"
+include MongoMapper::Grip
+
+class HasAttachmentTest < Test::Unit::TestCase
+  context "A Doc that has_grid_attachment :image" do
+    setup do
+      @document     = Doc.new
+      @dir          = File.dirname(__FILE__) + '/fixtures'
+      @image        = File.open("#{@dir}/cthulhu.png", 'r')
+      @file_system  = MongoMapper.database['fs.files']
+    end
+    
+    teardown do
+      @file_system.drop
+      @image.close
+    end
+
+    should "have many attachments" do
+      name,assoc = Doc.associations.first
+      assert_equal(:attachments, assoc.name)
+      assert_equal(:many, assoc.type)
+    end
+    
+    should "have :after_save callback" do
+      assert_equal(1, Doc.after_save.collect(&:method).count)
+    end
+    
+    should "have :before_destroy callback" do
+      assert_equal(1, Doc.before_destroy.collect(&:method).count)
+    end
+    
+    context "when assigned a file" do
+      setup do
+        @document.image = @image
+        @document.save!
+      end
+
+      should "should return an Attachment" do
+        assert_equal(MongoMapper::Grip::Attachment, @document.image.class)
+      end
+      
+      should "read file from grid store" do
+        assert_equal "image/png", @file_system.find_one(:filename => @document.image.grid_key)['contentType']
+      end  
+      
+      should "have :thumb variant" do
+        assert @document.image.respond_to?( :thumb )
+      end
+      
+      should "have 2 variants" do
+        assert_equal(2, @document.image.attached_variants.count)
+      end
+      
+      should "be resized" do
+        assert @document.image.file_size > @document.image.thumb.file_size
+        assert @document.image.file_size > @document.image.super_thumb.file_size
+      end
+      
+      should "retrieve variants from grid" do
+        assert_equal "image/png", @file_system.find_one(:filename => @document.image.thumb.grid_key)['contentType']
+      end
+      
+    end
+    
+  end
+    
+end

data/test/test_helper.rb

@@ -1,23 +1,23 @@
-require 'test/unit'
-require 'pp'
-
-require 'mongo_mapper'
-
+%w{test/unit shoulda factory_girl mongo_mapper factories}.each { |lib| require lib }
+require 'growler'
 require File.expand_path(File.dirname(__FILE__) + '/../lib/grip')
 
-MongoMapper.database = "test-attachments"
+TEST_DB = 'test-grip'
+
+MongoMapper.database = TEST_DB
 
 class Test::Unit::TestCase
-  def self.test(name, &block)
-    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
-    defined = instance_method(test_name) rescue false
-    raise "#{test_name} is already defined in #{self}" if defined
-    if block_given?
-      define_method(test_name, &block)
-    else
-      define_method(test_name) do
-        flunk "No implementation provided for #{name}"
-      end
+  def teardown
+    MongoMapper.database.collections.each do |coll|
+      coll.remove  
+    end
+  end
+
+  # Make sure that each test case has a teardown
+  # method to clear the db after each test.
+  def inherited(base)
+    base.define_method teardown do 
+      super
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: grip
 version: !ruby/object:Gem::Version 
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors: 
 - twoism
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-30 00:00:00 -05:00
+date: 2009-12-31 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,7 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
+- .DS_Store
 - .gitignore
 - LICENSE
 - README.rdoc
@@ -31,9 +32,15 @@ files:
 - VERSION
 - grip.gemspec
 - lib/grip.rb
+- lib/grip/attachment.rb
+- lib/grip/has_attachment.rb
+- test/factories.rb
 - test/fixtures/cthulhu.png
 - test/fixtures/sample.pdf
-- test/test_grip.rb
+- test/growler.rb
+- test/models.rb
+- test/test_grip_attachment.rb
+- test/test_has_attachment.rb
 - test/test_helper.rb
 has_rdoc: true
 homepage: http://github.com/twoism/grip
@@ -64,5 +71,9 @@ signing_key:
 specification_version: 3
 summary: GridFS attachments for MongoMapper
 test_files: 
-- test/test_grip.rb
+- test/factories.rb
+- test/growler.rb
+- test/models.rb
+- test/test_grip_attachment.rb
+- test/test_has_attachment.rb
 - test/test_helper.rb

data/test/test_grip.rb

@@ -1,91 +0,0 @@
-require "test_helper"
-
-class Foo
-  include MongoMapper::Document
-  include Grip
-  
-  has_grid_attachment :image, :versions => {:thumb => {:width=>50,:height=>50}}
-  has_grid_attachment :pdf
-  
-  def process_image opts
-    opts[:file]
-  end
-end
-
-class GripTest < Test::Unit::TestCase
-  def setup
-    MongoMapper.connection.drop_database "test-attachments"
-    MongoMapper.database = "test-attachments"
-    
-    dir    = File.dirname(__FILE__) + '/fixtures'
-    @pdf   = File.open("#{dir}/sample.pdf",  'r')
-    @image = File.open("#{dir}/cthulhu.png", 'r')
-    
-    @doc = Foo.create(:image => @image, :pdf => @pdf)
-    @doc.reload
-  end
-  
-  def teardown
-    @pdf.close
-    @image.close
-  end
-  
-  test "assigns keys correctly" do
-    assert_equal 27582, @doc.image_size
-    assert_equal 8775,  @doc.pdf_size
-    
-    assert_equal 'cthulhu.png', @doc.image_name
-    assert_equal 'sample.pdf',  @doc.pdf_name
-    
-    assert_equal "image/png",       @doc.image_content_type
-    assert_equal "image/png",       @doc.image_thumb_content_type
-    assert_equal "application/pdf", @doc.pdf_content_type
-    
-    assert_equal "foo/image/#{@doc.id}", @doc.image_path
-    assert_equal "foo/image_thumb/#{@doc.id}", @doc.image_thumb_path
-    assert_equal "foo/pdf/#{@doc.id}",   @doc.pdf_path
-    
-    collection = MongoMapper.database['fs.files']
-    
-    assert_equal "image/png", collection.find_one(:filename => @doc.image_path)['contentType']
-    assert_equal "application/pdf", collection.find_one(:filename => @doc.pdf_path)['contentType']
-  end
-  
-  test "responds to dynamic keys" do
-    [ :pdf_size, :pdf_path, :pdf_name, :pdf_content_type,
-      :image_size, :image_path, :image_name, :image_content_type,
-      :image_thumb_size, :image_thumb_path, :image_thumb_name, :image_thumb_content_type
-    ].each do |method|
-      assert @doc.respond_to?(method)
-    end
-  end
-  
-  test "callbacks assigned only once each" do
-    assert_equal(1, Foo.after_save.collect(&:method).count)
-    assert_equal(1, Foo.before_destroy.collect(&:method).count)
-  end
-  
-  test "saves attachments correctly" do
-    assert_equal "image/png",       @doc.image.content_type
-    assert_equal "application/pdf", @doc.pdf.content_type
-    
-    assert GridFS::GridStore.exist?(MongoMapper.database, @doc.image_path)
-    assert GridFS::GridStore.exist?(MongoMapper.database, @doc.pdf_path)
-  end
-  
-  test "cleans up attachments on destroy" do
-    assert GridFS::GridStore.exist?(MongoMapper.database, @doc.image_path)
-    assert GridFS::GridStore.exist?(MongoMapper.database, @doc.pdf_path)
-    
-    @doc.destroy
-    
-    assert ! GridFS::GridStore.exist?(MongoMapper.database, @doc.image_path)
-    assert ! GridFS::GridStore.exist?(MongoMapper.database, @doc.image_thumb_path)
-    assert ! GridFS::GridStore.exist?(MongoMapper.database, @doc.pdf_path)
-  end
-  
-  test "should raise invalid file exception" do
-    assert_raise(Grip::InvalidFileException) {  @doc.image = ""; @doc.save! }
-  end
-  
-end