em-ftpd-memory 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 935bb1e47a5d580f87e0b150f866074fdf5ac242
-  data.tar.gz: 976fcbab17763aeddf50197cd3bd36279fa7b7e8
+  metadata.gz: 8fd32c31bff6d70f1558c6909462a3edb19d675a
+  data.tar.gz: 99a62b6e7e4cdac319b33b813d2d1f26660a8fe7
 SHA512:
-  metadata.gz: 8d00f379e4d9b66db5f43aeabc4caa9588cd82ff6ecc93d67eeb06c84c506896b12f736a813652a1da5c741db55978c13aa5b21e158caa60b4b88f4a081ac9be
-  data.tar.gz: 5aac095867e9ed4ae16224ac3e852763d091d6471ed75dc0e73698d635b7c271c3ec2777055a5f21357033de79453e7004fdeee109f9e40aec0a3f2102679afd
+  metadata.gz: 5d2ac6295de54b6b0bc471203b4988b15f66fefa3bdd012a3369811beacd4a2190c5dd1babfd582a26bfed58fd9d5886380aa11de26ab06498f8c2a8bce148cd
+  data.tar.gz: 49c64f601a8dc2201e2237fe1847ad22f2168533261970d1f94c10d6139c0642c01a4cf53ee47b8866be9b3ac4b06e1bbd42a9d8ab5ff764e3f66516502253e5

data/em-ftpd-memory.gemspec

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "em-ftpd-memory"
-  spec.version       = "0.0.1"
+  spec.version       = "0.0.2"
   spec.authors       = ["chrislee35"]
   spec.email         = ["rubygems@chrislee.dhs.org"]
   spec.summary       = %q{Memory-based backing store for em-ftpd}

data/lib/em/ftpd/memory/authenticator.rb

@@ -3,10 +3,12 @@ require 'digest/md5'
 
 module EM::FTPD::Memory
   class User < Struct.new(:name, :credential); end
-  class InvalidPasswordAlgorithm < StandardError; end
+  class InvalidPasswordAlgorithmError < StandardError; end
   class NoSuchUserError < StandardError; end
-  class InvalidCredentialdError < StandardError; end
+  class InvalidCredentialError < StandardError; end
   class ExpiredCredentialError < StandardError; end
+  class MalformatedCredentialError < StandardError; end
+  class NoFurtherCredentialsAvailable < StandardError; end
 
   class Authenticator
     @@realms = Hash.new
@@ -21,6 +23,10 @@ module EM::FTPD::Memory
     def initialize(options = {})
       @users = Hash.new
       @pwalgo = options["pwalgo"] || "plain"
+      @pwalgo = "#{@pwalgo}_authentication".to_sym
+      unless self.respond_to?(@pwalgo)
+        raise InvalidPasswordAlgorithmError.new
+      end
     end
   
     def <<(user)
@@ -35,18 +41,12 @@ module EM::FTPD::Memory
       if @users[username].nil?
         raise NoSuchUserError.new
       end
-      # this prevents someone from setting "delete" as the authentication algorithm
-      algo = "#{@pwalgo}_authentication".to_sym
-      if self.respond_to?(algo)
-        self.send(algo, username, credential)
-      else
-        raise InvalidPasswordAlgorithmError.new
-      end
+      self.send(@pwalgo, username, credential)
     end
   
     def plain_authentication(username, credential)
       if @users[username].credential != credential
-        raise InvalidCredentialdError.new
+        raise InvalidCredentialError.new
       else
         return true
       end
@@ -54,6 +54,9 @@ module EM::FTPD::Memory
   
     def timed_md5_authentication(username, credential)
       seed, time, hash = credential.split(/:/, 3)
+      if hash.nil? or hash.length != 32
+        raise MalformatedCredentialError.new
+      end
       if (time.to_i - Time.now.to_i).abs > 300
         raise ExpiredCredentialError.new
       else

data/lib/em/ftpd/memory/driver.rb

@@ -3,21 +3,30 @@ module EM::FTPD::Memory
     def initialize(options = {})
       filesystem_name = options["filesystem_name"] || "default"
       realm = options["authentication_realm"] || "default"
-      @fs = FileSystem.getFileSystemByName(filesystem_name)
+      @fs = FileSystem.getFileSystem(filesystem_name)
       @authenticator = Authenticator.getAuthenticatorByRealm(realm, options)
+      @authenticated_user = nil
+      @server = Kernel.caller[0]
+      begin
+        $stderr.puts @server
+      rescue => e
+        $stderr.puts e
+        $stderr.puts e.backtrace
+      end
     end
     
     def change_dir(path, &block)
-      yield @fs.is_dir(path)
+      yield @fs.change_dir(path, @authenticated_user)
     end
 
     def dir_contents(path, &block)
-      yield @fs.list_files(path)
+      yield @fs.list_files(path, @authenticated_user)
     end
 
     def authenticate(user, pass, &block)
       begin
         @authenticator.authenticate(user, pass)
+        @authenticated_user = user
         yield true
       rescue Exception => e
         #puts e.backtrace
@@ -26,31 +35,32 @@ module EM::FTPD::Memory
     end
 
     def bytes(path, &block)
-      yield @fs.file_size(path)
+      yield @fs.file_size(path, @authenticated_user)
     end
 
     def get_file(path, &block)
-      yield @fs.file_contents(path)
+      yield @fs.file_contents(path, @authenticated_user)
     end
 
     def put_file(path, data, &block)
-      yield @fs.create_file(path, data)
+      yield @fs.create_file(path, data, @authenticated_user)
     end
 
     def delete_file(path, &block)
-      yield @fs.remove_file(path)
+      yield @fs.delete_file(path, @authenticated_user)
     end
 
     def delete_dir(path, &block)
-      yield @fs.delete_dir(path)
+      yield @fs.delete_dir(path, @authenticated_user)
     end
 
     def rename(from, to, &block)
-      yield @fs.rename(from, to)
+      yield @fs.rename(from, to, @authenticated_user)
     end
 
     def make_dir(path, &block)
-      yield @fs.create_dir(path)
-    end    
+      yield @fs.create_dir(path, @authenticated_user)
+    end
+    
   end
 end

data/lib/em/ftpd/memory/filesystem.rb

@@ -1,7 +1,9 @@
 module EM::FTPD::Memory
+  class InvalidPermissionsError < StandardError; end
+  
   class FileSystem
     @@filesystems = Hash.new
-    def self.getFileSystemByName(name)
+    def self.getFileSystem(name)
       if @@filesystems[name].nil?
         @@filesystems[name] = FileSystem.new
       end
@@ -9,7 +11,21 @@ module EM::FTPD::Memory
       return @@filesystems[name]
     end
     
+    def self.destroyFileSystem(name, force = false)
+      unless @@filesystems[name].nil?
+        if force
+          @@filesystems[name].destroy
+          @@filesystems.delete(name)
+        else
+          if @@filesystems[name].list_files("/").empty?
+            @@filesystems.delete(name)
+          end
+        end
+      end
+    end
+    
     def initialize()
+      @root_entry = EM::FTPD::DirectoryItem.new(:name => 'root', :directory => true, :size => 0, :permissions => 'rwxrwxrwx', :owner => 'root', :group => 'root')
       @root = {
         '/' => Array.new
       }
@@ -20,39 +36,30 @@ module EM::FTPD::Memory
       is_dir(path) || is_file(path)
     end
     
-    def list_files(path)
-      @root[path] || []
+    def chdir(path, user = nil)
+      is_dir(path) && use_allowed(path, :list, user)
     end
     
-    def file_size(path)
+    def list_files(path, user = nil)
+      return [] unless use_allowed?(path, :list, user)
+      @root[path] || [] # should this return false?
+    end
+    
+    def file_size(path, user = nil)
+      return false unless use_allowed?(path, :size, user)
       f = get_file(path)
       return false unless f
       f.size
     end
     
-    def file_contents(path)
+    def file_contents(path, user = nil)
+      return false unless use_allowed?(path, :read, user)
       # nil || false => false
       @contents[path] || false
     end
     
-    def get_file(path)
-      dirname = File.dirname(path)
-      basename = File.basename(path)
-      if is_dir(dirname)
-        return @root[dirname].find {|file| file.directory == false && file.name == basename}
-      end
-      nil
-    end
-    
-    def is_file(path)
-      @contents[path] || false
-    end
-    
-    def is_dir(path)
-      @root[path] != nil
-    end
-    
-    def create_file(path, data)
+    def create_file(path, data, user = "nobody")
+      return false unless use_allowed?(path, :create, user)
       dirname = File.dirname(path)
       basename = File.basename(path)
       if is_dir(dirname)
@@ -70,8 +77,9 @@ module EM::FTPD::Memory
       end
     end
     
-    def remove_file(path)
+    def delete_file(path, user = nil)
       if is_file(path)
+        return false unless use_allowed?(path, :delete, user)
         dirname = File.dirname(path)
         basename = File.basename(path)
         @root[dirname].reject! {|file| file.directory == false && file.name == basename}
@@ -81,8 +89,9 @@ module EM::FTPD::Memory
       false
     end
     
-    def delete_dir(path)
+    def delete_dir(path, user = nil)
       if is_dir(path) && @root[path].empty?
+        return false unless use_allowed?(path, :delete, user)
         @root.delete(path)
         dirname = File.dirname(path)
         basename = File.basename(path)
@@ -92,8 +101,9 @@ module EM::FTPD::Memory
       false
     end
     
-    def create_dir(path)
+    def create_dir(path, user = "nobody")
       if not exist?(path)
+        return false unless use_allowed?(path, :create, user)
         dirname = File.dirname(path)
         basename = File.basename(path)
         if is_dir(dirname)
@@ -105,9 +115,11 @@ module EM::FTPD::Memory
       return false
     end
     
-    def rename(from, to)
+    def rename(from, to, user = nil)
       return false if exist?(to)
       return false unless exist?(from)
+      return false unless use_allowed?(from, :delete, user)
+      return false unless use_allowed?(to, :create, user)
       
       from_dirname = File.dirname(from)
       from_basename = File.basename(from)
@@ -117,7 +129,8 @@ module EM::FTPD::Memory
       if from_dirname == to_dirname
         @root[from_dirname].find {|file| file.name == from_basename}.name = to_basename
       else
-        entry = @root[from_dirname].reject! {|file| file.name == from_basename}
+        entry = @root[from_dirname].find {|file| file.name == from_basename}
+        @root[from_dirname] -= [entry]
         entry.name = to_basename
         @root[to_dirname] << entry
       end
@@ -133,6 +146,119 @@ module EM::FTPD::Memory
       end
       return true
     end
+    
+    def destroy
+      @root.each_key do |d|
+        @root.delete(d)
+      end
+      @contents.each_key do |f|
+        @contents.delete(f)
+      end
+      GC.start
+    end
+    
+    def set_permissions(path, permissions, user = nil)
+      return false unless exist?(path)
+      raise InvalidPermissionsError.new if permissions.nil?
+      raise InvalidPermissionsError.new(permissions.to_s) unless permissions.class == String
+      raise InvalidPermissionsError.new(permissions) unless permissions =~ /^[r\.][w\.][x\.][r\.][w\.][x\.][r\.][w\.][x\.]$/
+      entry = get_entry(path)
+      return false unless entry
+      return false unless user and (entry.owner == user or user == "root")
+      entry.permissions = permissions
+      true
+    end
+    
+    def set_owner(path, owner, user = nil)
+      return false unless exist?(path) and owner and owner.class == String
+      entry = get_entry(path)
+      return false unless user and user == "root"
+      return false unless entry
+      entry.owner = owner
+      true
+    end
+
+    #private 
+    
+    def get_entry(path)
+      return @root_entry if path == '/'
+      dirname = File.dirname(path)
+      basename = File.basename(path)
+      if is_dir(dirname)
+        return @root[dirname].find {|entry| entry.name == basename}
+      end
+      nil
+    end
+    
+    def get_file(path)
+      dirname = File.dirname(path)
+      basename = File.basename(path)
+      if is_dir(dirname)
+        return @root[dirname].find {|file| file.directory == false && file.name == basename}
+      end
+      nil
+    end
+    
+    def is_file(path)
+      @contents[path] || false
+    end
+    
+    def is_dir(path)
+      @root[path] != nil
+    end
+    
+    def use_allowed?(path, use, username)
+      return true if username == 'root'
+      
+      dirname = File.dirname(path)
+      basename = File.basename(path)
+      # to do anything, you must be able to rx into the directory containing the entry
+      cwd = '/'
+      dirname.split(/\//).each do |dir|
+        next if dir == '/'
+        cwd << dir
+        return false unless allowed?(cwd, "rx", username)
+        cwd << '/'
+      end
+      
+      case use
+      when :read
+        return allowed?(path, 'r', username)
+      when :write
+        return allowed?(path, 'w', username)
+      when :list
+        return allowed?(path, 'rx', username)
+      when :size
+        return true # since we've already checked everything
+      when :delete
+        return allowed?(dirname, "rwx", username)
+      when :create
+        return allowed?(dirname, "rwx", username)
+      else
+        return false
+      end
+    end
+    
+    def allowed?(path, required_permissions, username)
+      entry = get_entry(path)
+      permissions = entry.permissions || 'rwxrwxrwx'
+      return false unless entry
+      if username.nil?
+        perms = permissions[6,3]
+      elsif entry.owner == username
+        perms = permissions[0,3]
+      else
+        perms = permissions[6,3]
+      end
+
+      return true if perms == "rwx"
+      required_permissions.each_char do |c|
+        if perms.index(c).nil?
+          return false
+        end
+      end
+      return true
+    end
 
   end
 end

data/test/test_authenticator.rb

@@ -0,0 +1,115 @@
+unless Kernel.respond_to?(:require_relative)
+	module Kernel
+		def require_relative(path)
+			require File.join(File.dirname(caller[0]), path.to_str)
+		end
+	end
+end
+
+require_relative 'helper'
+require 'digest/md5'
+include EM::FTPD::Memory
+
+class TestAuthenticator < Minitest::Test
+  def test_invalid_pwalgo
+    options = {
+      "pwalgo" => "nogood",
+      "authentication_realm" => "invalid"
+    }
+    assert_raises(InvalidPasswordAlgorithmError) do
+      Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    end
+  end
+    
+  def test_plain_login
+    options = {
+      "pwalgo" => "plain",
+      "authentication_realm" => "plain"
+    }
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    auth << User.new("test", "test")
+    assert_raises(NoSuchUserError) do
+      auth.authenticate("jerk", "noway")
+    end
+    
+    assert_raises(InvalidCredentialError) do
+      auth.authenticate("test", "noway")
+    end
+    
+    assert(auth.authenticate("test", "test"))
+  end
+  
+  def test_time_based_login
+    options = {
+      "pwalgo" => "timed_md5",
+      "authentication_realm" => "time_based"
+    }
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    auth << User.new("test", "test")
+    assert_raises(NoSuchUserError) do
+      auth.authenticate("jerk", "noway")
+    end
+    
+    assert_raises(MalformatedCredentialError) do
+      auth.authenticate("test", "noway")
+    end
+    
+    assert_raises(MalformatedCredentialError) do
+      auth.authenticate("test", "test")
+    end
+    
+    time = Time.now.to_i - 1200
+    seed = "this is a random seed"
+    expired_hash = Digest::MD5.hexdigest("#{seed}:#{time}:test")
+    expired_cred = "#{seed}:#{time}:#{expired_hash}"
+    
+    assert_raises(ExpiredCredentialError) do
+      auth.authenticate("test", expired_cred)
+    end
+    
+    time = Time.now.to_i
+    seed = "this is a random seed"
+    invalid_hash = Digest::MD5.hexdigest("#{seed}:#{time}:wrong")
+    invalid_cred = "#{seed}:#{time}:#{expired_hash}"
+
+    assert_raises(InvalidCredentialError) do
+      auth.authenticate("test", invalid_cred)
+    end
+
+    time = Time.now.to_i
+    seed = "this is a random seed"
+    valid_hash = Digest::MD5.hexdigest("#{seed}:#{time}:test")
+    valid_cred = "#{seed}:#{time}:#{valid_hash}"
+    
+    assert(auth.authenticate("test", valid_cred))
+  end
+  
+  def test_otp_login
+    options = {
+      "pwalgo" => "otp",
+      "authentication_realm" => "otp"
+    }
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
+    assert_raises(NoSuchUserError) do
+      auth.authenticate("jerk", "noway")
+    end
+    
+    assert_raises(InvalidCredentialError) do
+      auth.authenticate("test", "wrong")
+    end
+    
+    1.upto(4) do |i|    
+      assert(auth.authenticate("test","test#{i}"))
+    
+      assert_raises(InvalidCredentialError) do
+        auth.authenticate("test", "test#{i}")
+      end
+    end
+    
+    assert(auth.authenticate("test","test5"))
+    assert_raises(NoFurtherCredentialsAvailable) do
+      auth.authenticate("test", "test5")
+    end
+  end
+end

data/test/test_ftpd-memory.rb

@@ -9,6 +9,8 @@ end
 require_relative 'helper'
 require 'eventmachine'
 require 'em-ftpd'
+require 'digest/md5'
+include EM::FTPD::Memory
 
 class TestFTPDMemory < Minitest::Test
   def test_example
@@ -18,9 +20,9 @@ class TestFTPDMemory < Minitest::Test
       "pwalgo" => "otp",
       
     }
-    auth = EM::FTPD::Memory::Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
-    auth << EM::FTPD::Memory::User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
-    fs = EM::FTPD::Memory::FileSystem.getFileSystemByName(options["filesystem_name"])
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
+    auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
+    fs = FileSystem.getFileSystem(options["filesystem_name"])
     fs.create_dir("/pub")
     fs.create_file("/pub/helper.rb", "test/helper.rb")
     
@@ -31,38 +33,5 @@ class TestFTPDMemory < Minitest::Test
       end
     }
   end
-  
-  def test_plain_login
-  end
-  
-  def test_time_based_login
-  end
-  
-  def test_otp_login
-  end
-  
-  def test_file_creation
-  end
-  
-  def test_file_deletion
-  end
-  
-  def test_create_directory
-  end
-  
-  def test_delete_directory
-  end
-  
-  def test_file_rename
-  end
-  
-  def test_file_move_between_directories
-  end
-  
-  def test_chmod_file
-  end
-  
-  def test_chmod_directory
-  end
-  
+    
 end

data/test/test_memory_filesystem.rb

@@ -0,0 +1,182 @@
+unless Kernel.respond_to?(:require_relative)
+	module Kernel
+		def require_relative(path)
+			require File.join(File.dirname(caller[0]), path.to_str)
+		end
+	end
+end
+
+require_relative 'helper'
+
+include EM::FTPD::Memory
+
+class TestMemoryFilesystem < Minitest::Test
+  def test_filesystem_instance_retrieval
+    fs = FileSystem.getFileSystem(__method__)
+    fs2 = FileSystem.getFileSystem(__method__)
+    assert(fs.equal?(fs2))
+    FileSystem.destroyFileSystem(__method__)
+    fs2 = FileSystem.getFileSystem(__method__)
+    refute(fs.equal?(fs2))
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_file_creation
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_file("/helper.rb", "test/helper.rb")
+    assert(fs.exist?("/helper.rb"))
+    refute(fs.is_dir("/helper.rb"))
+    assert(fs.is_file("/helper.rb"))
+    assert_equal(169, fs.file_size("/helper.rb"))
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_file_deletion
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_file("/helper.rb", "test/helper.rb")
+    assert(fs.exist?("/helper.rb"))
+    refute(fs.is_dir("/helper.rb"))
+    assert(fs.is_file("/helper.rb"))
+    assert_equal(169, fs.file_size("/helper.rb"))
+    fs.delete_file("/helper.rb")
+    refute(fs.exist?("/helper.rb"))
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_create_directory
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_dir("/pub")
+    assert(fs.exist?("/pub"))
+    assert(fs.is_dir("/pub"))
+    refute(fs.is_file("/pub"))
+    
+    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.exist?("/pub/helper.rb"))
+    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    fs.delete_file("/pub/helper.rb")
+    refute(fs.exist?("/pub/helper.rb"))
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_delete_directory
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_dir("/pub")
+    assert(fs.exist?("/pub"))
+    assert(fs.is_dir("/pub"))
+    refute(fs.is_file("/pub"))
+    
+    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.exist?("/pub/helper.rb"))
+    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    refute(fs.delete_dir("/pub"))
+    fs.delete_file("/pub/helper.rb")
+    refute(fs.exist?("/pub/helper.rb"))
+    assert(fs.delete_dir("/pub"))
+    refute(fs.exist?("/pub"))
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_file_rename
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_dir("/pub")
+    assert(fs.exist?("/pub"))
+    assert(fs.is_dir("/pub"))
+    refute(fs.is_file("/pub"))
+    
+    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.exist?("/pub/helper.rb"))
+    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    fs.rename("/pub/helper.rb", "/pub/helper.txt")
+    refute(fs.exist?("/pub/helper.rb"))
+    assert(fs.exist?("/pub/helper.txt"))
+    assert_equal(169, fs.file_size("/pub/helper.txt"))
+    
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_file_move_between_directories
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_dir("/pub")
+    assert(fs.exist?("/pub"))
+    assert(fs.is_dir("/pub"))
+    refute(fs.is_file("/pub"))
+    fs.create_dir("/pub2")
+    assert(fs.exist?("/pub2"))
+    assert(fs.is_dir("/pub2"))
+    refute(fs.is_file("/pub2"))
+    
+    fs.create_file("/pub/helper.rb", "test/helper.rb")
+    assert(fs.exist?("/pub/helper.rb"))
+    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    fs.rename("/pub/helper.rb", "/pub2/helper.txt")
+    refute(fs.exist?("/pub/helper.rb"))
+    assert(fs.exist?("/pub2/helper.txt"))
+    assert_equal(169, fs.file_size("/pub2/helper.txt"))
+    
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_rename_directory
+    fs = FileSystem.getFileSystem(__method__)
+    fs.create_dir("/pub")
+    assert(fs.exist?("/pub"))
+    assert(fs.is_dir("/pub"))
+    refute(fs.is_file("/pub"))
+    fs.create_dir("/pub2")
+    assert(fs.exist?("/pub2"))
+    assert(fs.is_dir("/pub2"))
+    refute(fs.is_file("/pub2"))
+    fs.create_file("/pub3", "test/helper.rb")
+    assert(fs.exist?("/pub3"))
+    refute(fs.is_dir("/pub3"))
+    assert(fs.is_file("/pub3"))
+    assert_equal(169, fs.file_size("/pub3"))
+    
+    refute(fs.rename("/pub", "/pub2"))
+    refute(fs.rename("/pub", "/pub3"))
+    assert(fs.delete_file("/pub3"))
+    assert(fs.rename("/pub", "/pub3"))
+    
+    FileSystem.destroyFileSystem(__method__)
+  end
+  
+  def test_file_permissions
+    fs = FileSystem.getFileSystem(__method__)
+    assert_raises(InvalidPermissionsError) do
+      fs.set_permissions("/", "rwx", "root")
+    end
+    
+    refute(fs.set_permissions("/", "rwxr.xr.x", "nobody"))
+    assert(fs.set_permissions("/", "rwxr.xr.x", "root"))
+    refute(fs.create_dir("/pub"))
+    refute(fs.exist?("/pub"))
+    assert(fs.create_dir("/pub", "root"))
+    assert(fs.exist?("/pub"))
+    assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
+    assert(fs.exist?("/pub/helper.rb"))
+    assert(fs.delete_file("/pub/helper.rb"))
+    refute(fs.exist?("/pub/helper.rb"))
+    assert(fs.set_permissions("/pub", 'rwxr.xr.x', "root"))
+    refute(fs.create_file("/pub/helper.rb", "test/helper.rb"))
+    refute(fs.exist?("/pub/helper.rb"))
+    assert(fs.create_dir("/pub/pub2","root"))
+    assert(fs.create_dir("/pub/pub2/pub3","root"))
+    assert(fs.create_dir("/pub/pub2/pub3/pub4","root"))
+    assert(fs.set_permissions("/pub/pub2/pub3", "rwx......", "root"))
+    assert_equal(0, fs.list_files("/pub/pub2/pub3").length)
+    assert_equal(1, fs.list_files("/pub/pub2/pub3", "root").length)
+    refute(fs.create_file("/pub/pub2/pub3/pub4/helper.rb", "test/helper.rb"))
+    assert(fs.create_file("/pub/pub2/pub3/pub4/helper.rb", "test/helper.rb", "root"))
+    refute(fs.file_size("/pub/pub2/pub3/pub4/helper.rb"))
+    assert_equal(169, fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "root"))
+
+
+    assert_equal(0, fs.list_files("/pub/pub2/pub3", "charlie").length)
+    refute(fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "charlie"))
+    assert(fs.set_owner("/pub/pub2/pub3", "charlie", "root"))
+    assert_equal(1, fs.list_files("/pub/pub2/pub3", "charlie").length)
+    assert_equal(169, fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "charlie"))
+    
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: em-ftpd-memory
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - chrislee35
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-14 00:00:00.000000000 Z
+date: 2015-03-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-ftpd
@@ -98,7 +98,9 @@ files:
 - lib/em/ftpd/memory/driver.rb
 - lib/em/ftpd/memory/filesystem.rb
 - test/helper.rb
+- test/test_authenticator.rb
 - test/test_ftpd-memory.rb
+- test/test_memory_filesystem.rb
 homepage: https://github.com/chrislee35/em-ftpd-memory
 licenses:
 - MIT
@@ -125,4 +127,6 @@ specification_version: 4
 summary: Memory-based backing store for em-ftpd
 test_files:
 - test/helper.rb
+- test/test_authenticator.rb
 - test/test_ftpd-memory.rb
+- test/test_memory_filesystem.rb