gnuside-mongoid-grid_fs 1.9.1

data/test/mongoid-grid_fs_test.rb

@@ -0,0 +1,247 @@
+require_relative 'helper'
+
+Testing Mongoid::GridFs do
+##
+#
+  GridFS =
+  GridFs =
+    Mongoid::GridFS
+
+  prepare do
+    GridFS::File.delete_all
+    GridFS::Chunk.delete_all
+  end
+
+##
+#
+  context '#put' do
+
+    test 'default' do
+      filename = __FILE__
+      basename = File.basename(filename)
+
+      g = assert{ GridFS.put(filename) }
+
+      assert{ g.filename =~ %r| #{ object_id_re } / #{ basename } \Z|imox }
+      assert{ g.content_type == "application/x-ruby" }
+      assert{ g.data == IO.read(filename) }
+    end
+
+    test 'with a :filename' do
+      filename = 'path/info/a.rb'
+
+      g = assert{ GridFS.put(__FILE__, :filename => filename) }
+
+      assert{ g.filename == filename }
+    end
+
+    test 'with your own attributes' do
+      my_value = "my_value"
+
+      g = assert{ GridFS.put(__FILE__, :my_value => my_value) }
+
+      assert{ g.my_value == my_value }
+    end
+
+    test 'when error occurs (eg. missing file)' do
+      file = '/path/to/missing'
+
+      assert_raises(Errno::ENOENT){ GridFs.put(file) }
+    end
+
+  end
+
+
+##
+#
+  context '#get' do
+
+    test 'default' do
+      id = assert{ GridFS::File.last.id }
+      g = assert{ GridFs.get(id) }
+    end
+
+  end
+
+##
+#
+  context '#delete' do
+
+    test 'default' do
+      id = assert{ GridFS::File.last.id }
+      g = assert{ GridFs.get(id) }
+      assert{ GridFs.delete(id) }
+      assert_raises( Mongoid::Errors::DocumentNotFound){ GridFs.get(id) }
+    end
+
+  end
+
+##
+#
+  context '[] and []=' do
+
+    test 'default' do
+      path = 'a.rb'
+      data = IO.read(__FILE__)
+
+      sio = SIO.new(path, data)
+
+      g = assert{ GridFs[path] = sio and GridFs[path] }
+
+      assert{ g.data == data }
+      assert{ g.content_type == "application/x-ruby" }
+
+      before = GridFs::File.count
+
+      assert{ GridFs[path] = SIO.new(path, 'foobar') }
+      assert{ GridFs[path].data == 'foobar' }
+
+      after = GridFs::File.count
+
+      created = after - before
+
+      assert{ created.zero? }
+    end
+
+##
+#
+  context 'data uris' do
+
+    test 'default' do
+      id = assert{ GridFS::File.last.id }
+      g = assert{ GridFs.get(id) }
+
+      content_type = g.content_type
+      base64 = [g.to_s].pack('m').chomp
+
+      data_uri = "data:#{ content_type };base64,".concat(base64)
+
+      assert{ g.data_uri == data_uri }
+    end
+
+  end
+
+##
+#
+  context 'slicing and dicing' do
+
+    test 'range' do
+      id = assert { GridFS::File.last.id }
+      g = assert { GridFs.get(id) }
+      assert { g.data[1..3] == g.slice(1..3) }
+    end
+
+    test 'start and length' do
+      id = assert { GridFS::File.last.id }
+      g = assert { GridFs.get(id) }
+      assert { g.data[1, 3] == g.slice(1, 3) }
+    end
+
+    test 'just a single param' do
+      id = assert { GridFS::File.last.id }
+      g = assert {GridFs.get(id) }
+
+      assert {g.data[1] == g.slice(1) }
+    end
+
+    test 'getting the last index' do
+      id = assert { GridFS::File.last.id }
+      g = assert {GridFs.get(id) }
+      assert {g.data[-1] == g.slice(-1) }
+    end
+
+    test 'yanking from the end of the data' do
+      id = assert { GridFS::File.last.id }
+      g = assert {GridFs.get(id) }
+      assert {g.data[-3, 2] == g.slice(-3, 2) }
+    end
+
+    test 'multiple chunks...' do
+      path = 'slice_and_dice.txt'
+
+      assert { GridFs[path] = SIO.new(path, "foobar" * 256 * 1024) }
+
+      g = GridFs[path]
+
+      assert { g.chunks.count > 0 }
+      assert { g.data[10, (256 * 1024 * 2)] == g.slice(10, (256 * 1024 * 2)) }
+    end
+  end
+
+##
+#
+  context 'iterating each chunk' do
+    test 'having file size more than 42mb' do
+      require 'tempfile'
+
+      orig, copy = %w{orig copy}.map do |suffix|
+        Tempfile.new("mongoid-grid_fs~43mb.#{suffix}")
+      end
+
+      assert system("dd if=/dev/zero of=#{orig.path} bs=#{43*1024*1024} count=1 &> /dev/null")
+
+      GridFs.get(GridFs.put(orig.path).id).each do |chunk|
+        copy.print(chunk.to_s)
+      end
+
+      assert { File.size(copy.path) == File.size(orig.path) }
+    end
+  end
+
+##
+#
+  context 'namespaces' do
+    test 'default' do
+      assert{ GridFs.namespace.prefix == 'fs' }
+      assert{ GridFs.file_model.collection_name.to_s == 'fs.files' }
+      assert{ GridFs.chunk_model.collection_name.to_s == 'fs.chunks' }
+    end
+
+    test 'new' do
+      ns = GridFs.namespace_for(:ns)
+
+      assert{ ns.prefix == 'ns' }
+
+      assert{ ns.file_model < Mongoid::Document }
+      assert{ ns.file_model.collection_name.to_s == 'ns.files' }
+
+      assert{ ns.chunk_model < Mongoid::Document }
+      assert{ ns.chunk_model.collection_name.to_s == 'ns.chunks' }
+
+      assert{ ns.file_model.destroy_all }
+
+      count = GridFs::File.count
+
+      assert{ ns.file_model.count == 0}
+      assert{ ns.put __FILE__ }
+      assert{ ns.file_model.count == 1}
+
+      assert{ count == GridFs::File.count }
+    end
+  end
+
+  end
+
+##
+#
+  context 'rails' do
+    test 'paths' do
+      testdir = File.dirname(__FILE__)
+      gemdir = File.dirname(testdir)
+      libdir = File.join(gemdir, 'lib')
+
+      expanded = proc{|paths| Array(paths).map{|path| File.expand_path(path)}}
+
+      assert{
+        expanded[ Mongoid::GridFS::Engine.paths['app/models'] ] == expanded[ libdir ]
+      }
+    end
+  end
+
+protected
+  def object_id_re
+    object_id = defined?(Moped::BSON) ? Moped::BSON::ObjectId.new : BSON::ObjectId.new
+
+    %r| \w{#{ object_id.to_s.size }} |iomx
+  end
+end

data/test/testing.rb

@@ -0,0 +1,196 @@
+# -*- encoding : utf-8 -*-
+require 'test/unit'
+
+testdir = File.expand_path(File.dirname(__FILE__))
+rootdir = File.dirname(testdir)
+libdir = File.join(rootdir, 'lib')
+
+STDOUT.sync = true
+
+$:.unshift(testdir) unless $:.include?(testdir)
+$:.unshift(libdir) unless $:.include?(libdir)
+$:.unshift(rootdir) unless $:.include?(rootdir)
+
+class Testing
+  class Slug < ::String
+    def Slug.for(*args)
+      string = args.flatten.compact.join('-')
+      words = string.to_s.scan(%r/\w+/)
+      words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      new(words.join('-').downcase)
+    end
+  end
+  
+  class Context
+    attr_accessor :name
+
+    def initialize(name, *args)
+      @name = name
+    end
+
+    def to_s
+      Slug.for(name)
+    end
+  end
+end
+
+def Testing(*args, &block)
+  Class.new(::Test::Unit::TestCase) do
+
+  ## class methods
+  #
+    class << self
+      def contexts
+        @contexts ||= []
+      end
+
+      def context(*args, &block)
+        return contexts.last if(args.empty? and block.nil?)
+
+        context = Testing::Context.new(*args)
+        contexts.push(context)
+
+        begin
+          block.call(context)
+        ensure
+          contexts.pop
+        end
+      end
+
+      def slug_for(*args)
+        string = [context, args].flatten.compact.join('-')
+        words = string.to_s.scan(%r/\w+/)
+        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words.join('-').downcase.sub(/_$/, '')
+      end
+
+      def name() const_get(:Name) end
+
+      def testno()
+        '%05d' % (@testno ||= 0)
+      ensure
+        @testno += 1
+      end
+
+      def testing(*args, &block)
+        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        define_method(method, &block)
+      end
+
+      def test(*args, &block)
+        testing(*args, &block)
+      end
+
+      def setup(&block)
+        define_method(:setup, &block) if block
+      end
+
+      def teardown(&block)
+        define_method(:teardown, &block) if block
+      end
+
+      def prepare(&block)
+        @prepare ||= []
+        @prepare.push(block) if block
+        @prepare
+      end
+
+      def cleanup(&block)
+        @cleanup ||= []
+        @cleanup.push(block) if block
+        @cleanup
+      end
+    end
+
+  ## configure the subclass!
+  #
+    const_set(:Testno, '0')
+    slug = slug_for(*args).gsub(%r/-/,'_')
+    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
+    name = name.upcase!
+    const_set(:Name, name)
+    const_set(:Missing, Object.new.freeze)
+
+  ## instance methods
+  #
+    alias_method('__assert__', 'assert')
+
+    def assert(*args, &block)
+      if args.size == 1 and args.first.is_a?(Hash)
+        options = args.first
+        expected = getopt(:expected, options){ missing }
+        actual = getopt(:actual, options){ missing }
+        if expected == missing and actual == missing
+          actual, expected, *ignored = options.to_a.flatten
+        end
+        expected = expected.call() if expected.respond_to?(:call)
+        actual = actual.call() if actual.respond_to?(:call)
+        assert_equal(expected, actual)
+      end
+
+      if block
+        label = "assert(#{ args.join(' ') })"
+        result = nil
+        assert_nothing_raised{ result = block.call }
+        __assert__(result, label)
+        result
+      else
+        result = args.shift
+        label = "assert(#{ args.join(' ') })"
+        __assert__(result, label)
+        result
+      end
+    end
+
+    def missing
+      self.class.const_get(:Missing)
+    end
+
+    def getopt(opt, hash, options = nil, &block)
+      [opt.to_s, opt.to_s.to_sym].each do |key|
+        return hash[key] if hash.has_key?(key)
+      end
+      default =
+        if block
+          block.call
+        else
+          options.is_a?(Hash) ? options[:default] : nil
+        end
+      return default
+    end
+
+    def subclass_of exception
+      class << exception
+        def ==(other) super or self > other end
+      end
+      exception
+    end
+
+  ##
+  #
+    module_eval(&block)
+
+    self.setup()
+    self.prepare.each{|b| b.call()}
+
+    at_exit{ 
+      self.teardown()
+      self.cleanup.each{|b| b.call()}
+    }
+
+    self
+  end
+end
+
+
+if $0 == __FILE__
+
+  Testing 'Testing' do
+    testing('foo'){ assert true }
+    test{ assert true }
+    p instance_methods.grep(/test/)
+  end
+
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: gnuside-mongoid-grid_fs
+version: !ruby/object:Gem::Version
+  version: 1.9.1
+platform: ruby
+authors:
+- Ara T. Howard
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.19'
+description: a mongoid 3/moped compatible implementation of the grid_fs specification
+email: ara.t.howard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/app/models/mongoid/grid_fs.rb
+- lib/app/models/mongoid/grid_fs/fs/chunk.rb
+- lib/app/models/mongoid/grid_fs/fs/file.rb
+- lib/mongoid-grid_fs.rb
+- gnuside-mongoid-grid_fs.gemspec
+- test/helper.rb
+- test/mongoid-grid_fs_test.rb
+- test/testing.rb
+homepage: https://github.com/ahoward/mongoid-grid_fs
+licenses:
+- Ruby
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: codeforpeople
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: mongoid-grid_fs
+test_files: []