em-ftpd-memory 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff070a000cded7f1c145979f7a4c42285e2c1075
-  data.tar.gz: f09bce2a5fdf592df680dd9c76512cfd0423940b
+  metadata.gz: 7c715cab895aa1f0db447b97d891e22c84cd52ae
+  data.tar.gz: 30665d3c15e7c72b9ad0f14cd0d621d2f2057e1d
 SHA512:
-  metadata.gz: 4384dee7ef945d52725be5732013ab356e54a7d1cf07833a971ffee061405864a1dce0e91c453e95f6643f96f7f2e07a9b96574c8edc072d12b6f2841c898914
-  data.tar.gz: 4b5da1d0cdbc510f8824043b7322a842df89117c98aabca89613809286e333562714adeacca34a4b505154ad79d6e3c352d4855ed6b80369b0c919ac873139b0
+  metadata.gz: 23d78443456ded147acc79c0c47063bc8bd295dedfc01c6099452e4bbfbfff4ecaafe416eb58ef106dd71542df51059553523205cb0ee828acfd22a7605b9aea
+  data.tar.gz: 4c4305f41b38491f6f206f253d9c2d7cb60a4c6fcff157ca974844b718bab40073ac19c2b4a01a289c1786c9b676bb470af80f05878c916aa0b201dee3132fbb

data/README.md

@@ -24,40 +24,50 @@ Or install it yourself as:
 	
     options = {
       "filesystem_name" => "boss",
-      "authentication_realm" => "georgia",
-      "pwalgo" => "otp",
-      
+      "authentication_realm" => "georgia"
     }
-	# set up the authentication
-    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"], options)
-	# add a test user
-    auth << User.new("test", "test1\ntest2\ntest3\ntest4\ntest5")
-	# create the filesystem
+    # set up the authentication
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"])
+    # add a test user
+    auth << User.new(:name => "test", :algo => "otp", :credential => "test1\ntest2\ntest3\ntest4\ntest5")
+    # add an anonymous user, note: algo defaults to none if there are no credentials are specified
+    auth << User.new(:name => "anonymous")
+    # create the filesystem
     fs = FileSystem.getFileSystem(options["filesystem_name"])
-	# add a pub folder
+    # add a pub folder
     fs.create_dir("/pub", 'root')
-	# add a file to the pub folder as root
+    # add a file to the pub folder as root
     fs.create_file("/pub/helper.rb", "test/helper.rb", 'root')
-	# chmod 755 /pub
+    # chmod 755 /pub
     fs.set_permissions("/pub", 'rwxr.xr.x', "root")
-	# create /uploads as root
+    # create /uploads as root
     fs.create_dir("/uploads", 'root')
-	# chmod 777 /uploads
+    # chmod 777 /uploads
     fs.set_permissions("/uploads", "rwxrwxrwx", "root")
     # create /users as root
     fs.create_dir("/users", 'root')
-	# chmod 755 /users
+    # chmod 755 /users
     fs.set_permissions("/users", "rwxr.xr.x", "root")
-	# create a personal directory for hiro, miyako, and pilar, (and add their test user)
+    # create a personal directory for hiro, miyako, and pilar, (and add their test user)
     ["hiro", "miyako", "pilar"].each do |username|
+      # create a home directory
       fs.create_dir("/users/#{username}", 'root')
-	  # set the permissions so that no one else can access it
+      # set the permissions so that no one else can access it
       fs.set_permissions("/users/#{username}", "rwx......", "root")
-	  # set the owner to the user
+      # set the owner to the user
       fs.set_owner("/users/#{username}", username, 'root')
-      auth << User.new(username, username)
+      # add the user to the authentication realm
+      auth << User.new(:name => username, :algo => "plain", :credential => username, :groups => ["testing"])
     end
     
+    # since hiro, miyako, and pilar are all in the "testing" group, I can
+    # create a shared folder for them, but the "test" user won't be able to access
+    fs.create_dir("/shared", 'root')
+    fs.set_permissions("/shared", 'rwxr.xr.x', 'root')
+    fs.create_dir("/shared/testing", 'root')
+    fs.set_group("/shared/testing", 'testing', 'root')
+    fs.set_permissions("/shared/testing", 'rwxrwx...', 'root')
+     
     EM.run {
       EventMachine::start_server("0.0.0.0", 2021, EM::FTPD::Server, EM::FTPD::Memory::Driver, options)
     }

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.6"
+  spec.version       = "0.0.7"
   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

@@ -2,26 +2,43 @@ require 'em-ftpd'
 require 'digest/md5'
 
 module EM::FTPD::Memory
-  class User < Struct.new(:name, :algo, :credential); end
   class InvalidPasswordAlgorithmError < StandardError; end
   class NoSuchUserError < StandardError; end
   class InvalidCredentialError < StandardError; end
   class ExpiredCredentialError < StandardError; end
   class MalformatedCredentialError < StandardError; end
+  class ReplayCredentialError < StandardError; end
   class NoFurtherCredentialsAvailable < StandardError; end
+  
+  class TimedToken < Struct.new(:time, :token); end
+  
+  class User
+    ATTRS = [:name, :algo, :credential, :groups]
+    attr_accessor(*ATTRS)
+
+    def initialize(options)
+      options.each do |attr, value|
+        self.send("#{attr}=", value)
+      end
+      @algo ||= (@credential) ? 'plain' : 'none'
+      @groups ||= []
+      raise ArgumentError.new("User requires a :name") unless @name
+    end
+  end
 
   class Authenticator
     @@realms = Hash.new
+    TOKEN_VALIDITY_PERIOD = 300
     def self.getAuthenticatorByRealm(realm)
       if @@realms[realm].nil?
         @@realms[realm] = Authenticator.new
       end
-      #puts "returning Authenticator of realm #{realm}"
       @@realms[realm]
     end
   
     def initialize
       @users = Hash.new
+      @used_tokens = Array.new
     end
   
     def <<(user)
@@ -42,6 +59,11 @@ module EM::FTPD::Memory
       end
       self.send(@users[username].algo, username, credential)
     end
+    
+    # this can be used for anonymous accounts
+    def none_authentication(username, credential)
+      return true
+    end
   
     def plain_authentication(username, credential)
       if @users[username].credential != credential
@@ -56,10 +78,13 @@ module EM::FTPD::Memory
       if hash.nil? or hash.length != 32
         raise MalformatedCredentialError.new
       end
-      if (time.to_i - Time.now.to_i).abs > 300
+      if (time.to_i - Time.now.to_i).abs > TOKEN_VALIDITY_PERIOD
         raise ExpiredCredentialError.new
       else
         if Digest::MD5.hexdigest("#{seed}:#{time}:#{@users[username].credential}") == hash
+          unless check_and_set_token(time.to_i, seed)
+            raise ReplayCredentialError.new
+          end
           return true
         else
           raise InvalidCredentialError.new
@@ -80,5 +105,26 @@ module EM::FTPD::Memory
         raise InvalidCredentialError.new        
       end
     end
+    
+    def groups(username)
+      if @users[username].nil?
+        raise NoSuchUserError.new
+      end
+      @users[username].groups
+    end
+    
+    private
+    
+    def check_and_set_token(time, token)
+      # clean up stale tokens
+      @used_tokens.reject! {|t| t.time < Time.now.to_i - TOKEN_VALIDITY_PERIOD}
+      # check if token is replayed
+      if @used_tokens.find {|t| t.time == time and t.token == token}
+        return false
+      end
+      # add new token
+      @used_tokens << TimedToken.new(time, token)
+      true
+    end
   end
 end

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

@@ -4,8 +4,9 @@ module EM::FTPD::Memory
       filesystem_name = options["filesystem_name"] || "default"
       realm = options["authentication_realm"] || "default"
       @fs = FileSystem.getFileSystem(filesystem_name)
-      @authenticator = Authenticator.getAuthenticatorByRealm(realm, options)
+      @authenticator = Authenticator.getAuthenticatorByRealm(realm)
       @authenticated_user = nil
+      @authenticated_user_groups = []
       @server = Kernel.caller[0]
       begin
         $stderr.puts @server
@@ -16,17 +17,18 @@ module EM::FTPD::Memory
     end
     
     def change_dir(path, &block)
-      yield @fs.change_dir(path, @authenticated_user)
+      yield @fs.change_dir(path, @authenticated_user, @authenticated_user_groups)
     end
 
     def dir_contents(path, &block)
-      yield @fs.list_files(path, @authenticated_user)
+      yield @fs.list_files(path, @authenticated_user, @authenticated_user_groups)
     end
 
     def authenticate(user, pass, &block)
       begin
         @authenticator.authenticate(user, pass)
         @authenticated_user = user
+        @authenticated_user_groups = @authenticator.groups(user)
         yield true
       rescue Exception => e
         #puts e.backtrace
@@ -35,35 +37,35 @@ module EM::FTPD::Memory
     end
 
     def bytes(path, &block)
-      yield @fs.file_size(path, @authenticated_user)
+      yield @fs.file_size(path, @authenticated_user, @authenticated_user_groups)
     end
 
     def get_file(path, &block)
-      yield @fs.file_contents(path, @authenticated_user)
+      yield @fs.file_contents(path, @authenticated_user, @authenticated_user_groups)
     end
 
     def put_file(path, data, &block)
-      yield @fs.create_file(path, data, @authenticated_user)
+      yield @fs.create_file(path, data, @authenticated_user, @authenticated_user_groups)
     end
 
     def delete_file(path, &block)
-      yield @fs.delete_file(path, @authenticated_user)
+      yield @fs.delete_file(path, @authenticated_user, @authenticated_user_groups)
     end
 
     def delete_dir(path, &block)
-      yield @fs.delete_dir(path, @authenticated_user)
+      yield @fs.delete_dir(path, @authenticated_user, @authenticated_user_groups)
     end
 
     def rename(from, to, &block)
-      yield @fs.rename(from, to, @authenticated_user)
+      yield @fs.rename(from, to, @authenticated_user, @authenticated_user_groups)
     end
 
     def make_dir(path, &block)
-      yield @fs.create_dir(path, @authenticated_user)
+      yield @fs.create_dir(path, @authenticated_user, @authenticated_user_groups)
     end
     
     def mtime(path, &block)
-      yield @fs.modified_time(path, @authenticated_user)
+      yield @fs.modified_time(path, @authenticated_user, @authenticated_user_groups)
     end
     
   end

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

@@ -23,7 +23,6 @@ module EM::FTPD::Memory
       if @@filesystems[name].nil?
         @@filesystems[name] = FileSystem.new
       end
-      #puts "returning FileSystem named #{name}"
       return @@filesystems[name]
     end
     
@@ -42,7 +41,14 @@ module EM::FTPD::Memory
 
 
     def initialize
-      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :group => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
+      @root = MemoryDirectoryItem.new(
+        :name => '/', 
+        :owner => 'root', 
+        :group => 'root', 
+        :directory => true, 
+        :permissions => "rwxr.xr.x", 
+        :contents => Hash.new
+      )
     end
 
     def exist?(path)
@@ -113,7 +119,14 @@ module EM::FTPD::Memory
           item.contents = contents
           item.size = contents.length
         else # create new
-          dir.contents[basename] = MemoryDirectoryItem.new(:name => basename, :owner => user, :size => contents.length, :contents => contents, :permissions => permissions)
+          dir.contents[basename] = MemoryDirectoryItem.new(
+            :name => basename, 
+            :owner => user,
+            :group => groups.first || "nogroup",
+            :size => contents.length,
+            :contents => contents, 
+            :permissions => permissions
+          )
         end
         return true
       else
@@ -154,7 +167,13 @@ module EM::FTPD::Memory
         basename = File.basename(path)
         parent = get_item(dirname)
         if parent and parent.directory
-          parent.contents[basename] = MemoryDirectoryItem.new(:name => basename, :directory => true, :owner => user, :contents => Hash.new)
+          parent.contents[basename] = MemoryDirectoryItem.new(
+            :name => basename, 
+            :directory => true, 
+            :owner => user, 
+            :group => groups.first || "nogroup",
+            :contents => Hash.new
+          )
           return true
         end
       end
@@ -184,7 +203,14 @@ module EM::FTPD::Memory
     end
     
     def destroy
-      @root = MemoryDirectoryItem.new(:name => '/', :owner => 'root', :group => 'root', :directory => true, :permissions => "rwxr.xr.x", :contents => Hash.new)
+      @root = MemoryDirectoryItem.new(
+        :name => '/', 
+        :owner => 'root', 
+        :group => 'root', 
+        :directory => true, 
+        :permissions => "rwxr.xr.x", 
+        :contents => Hash.new
+      )
       GC.start
     end
     
@@ -212,9 +238,9 @@ module EM::FTPD::Memory
     def set_group(path, group, user = nil, groups = [])
       item = get_item(path)
       return false unless item and group and group.class == String
-      return false unless user and user == "root"
-      return false unless groups.index(group)
+      return false unless (user and user == "root") or groups.index(group)
       item.group = group
+      true
     end
 
     #private

data/test/helper.rb

@@ -1,5 +1,6 @@
 require 'minitest/autorun'
 require 'minitest/test'
 require 'minitest/unit'
+require 'minitest/pride'
 include MiniTest::Assertions
 require File.expand_path('../../lib/em/ftpd/memory.rb', __FILE__)

data/test/test_authenticator.rb

@@ -14,13 +14,13 @@ class TestAuthenticator < Minitest::Test
   def test_invalid_pwalgo
     assert_raises(InvalidPasswordAlgorithmError) do
       auth = Authenticator.getAuthenticatorByRealm(__method__)
-      auth << User.new("test", "nogood", "test")
+      auth << User.new(:name => "test", :algo => "nogood", :credential => "test")
     end
   end
     
   def test_plain_login
     auth = Authenticator.getAuthenticatorByRealm(__method__)
-    auth << User.new("test", "plain", "test")
+    auth << User.new(:name => "test", :algo => "plain", :credential => "test")
     assert_raises(NoSuchUserError) do
       auth.authenticate("jerk", "noway")
     end
@@ -34,7 +34,7 @@ class TestAuthenticator < Minitest::Test
   
   def test_time_based_login
     auth = Authenticator.getAuthenticatorByRealm(__method__)
-    auth << User.new("test", "timed_md5", "test")
+    auth << User.new(:name => "test", :algo => "timed_md5", :credential => "test")
     assert_raises(NoSuchUserError) do
       auth.authenticate("jerk", "noway")
     end
@@ -59,7 +59,7 @@ class TestAuthenticator < Minitest::Test
     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}"
+    invalid_cred = "#{seed}:#{time}:#{invalid_hash}"
 
     assert_raises(InvalidCredentialError) do
       auth.authenticate("test", invalid_cred)
@@ -71,11 +71,16 @@ class TestAuthenticator < Minitest::Test
     valid_cred = "#{seed}:#{time}:#{valid_hash}"
     
     assert(auth.authenticate("test", valid_cred))
+    
+    assert_raises(ReplayCredentialError) do
+      auth.authenticate("test", valid_cred)
+    end
+    
   end
   
   def test_otp_login
     auth = Authenticator.getAuthenticatorByRealm(__method__)
-    auth << User.new("test", "otp", "test1\ntest2\ntest3\ntest4\ntest5")
+    auth << User.new(:name => "test", :algo => "otp", :credential => "test1\ntest2\ntest3\ntest4\ntest5")
     assert_raises(NoSuchUserError) do
       auth.authenticate("jerk", "noway")
     end
@@ -97,4 +102,14 @@ class TestAuthenticator < Minitest::Test
       auth.authenticate("test", "test5")
     end
   end
+  
+  def test_anonymous_login
+    auth = Authenticator.getAuthenticatorByRealm(__method__)
+    auth << User.new(:name => "anonymous")
+    assert_raises(NoSuchUserError) do
+      auth.authenticate("jerk", "noway")
+    end
+    
+    assert(auth.authenticate("anonymous","test@example.com"))
+  end
 end

data/test/test_ftpd-memory.rb

@@ -14,12 +14,18 @@ include EM::FTPD::Memory
 
 class TestFTPDMemory < Minitest::Test
   def test_example
+    options = {
+      "filesystem_name" => "boss",
+      "authentication_realm" => "georgia"
+    }
     # set up the authentication
-    auth = Authenticator.getAuthenticatorByRealm("georgia")
+    auth = Authenticator.getAuthenticatorByRealm(options["authentication_realm"])
     # add a test user
-    auth << User.new("test", "otp", "test1\ntest2\ntest3\ntest4\ntest5")
+    auth << User.new(:name => "test", :algo => "otp", :credential => "test1\ntest2\ntest3\ntest4\ntest5")
+    # add an anonymous user, note: algo defaults to none if there are no credentials are specified
+    auth << User.new(:name => "anonymous")
     # create the filesystem
-    fs = FileSystem.getFileSystem("boss")
+    fs = FileSystem.getFileSystem(options["filesystem_name"])
     # add a pub folder
     fs.create_dir("/pub", 'root')
     # add a file to the pub folder as root
@@ -36,18 +42,24 @@ class TestFTPDMemory < Minitest::Test
     fs.set_permissions("/users", "rwxr.xr.x", "root")
     # create a personal directory for hiro, miyako, and pilar, (and add their test user)
     ["hiro", "miyako", "pilar"].each do |username|
+      # create a home directory
       fs.create_dir("/users/#{username}", 'root')
       # set the permissions so that no one else can access it
       fs.set_permissions("/users/#{username}", "rwx......", "root")
       # set the owner to the user
       fs.set_owner("/users/#{username}", username, 'root')
-      auth << User.new(username, "plain", username)
+      # add the user to the authentication realm
+      auth << User.new(:name => username, :algo => "plain", :credential => username, :groups => ["testing"])
     end
     
-    options = {
-      "filesystem_name" => "boss",
-      "authentication_realm" => "georgia"
-    }
+    # since hiro, miyako, and pilar are all in the "testing" group, I can
+    # create a shared folder for them, but the "test" user won't be able to access
+    fs.create_dir("/shared", 'root')
+    fs.set_permissions("/shared", 'rwxr.xr.x', 'root')
+    fs.create_dir("/shared/testing", 'root')
+    fs.set_group("/shared/testing", 'testing', 'root')
+    fs.set_permissions("/shared/testing", 'rwxrwx...', 'root')
+    
     EM.run {
       EventMachine::start_server("0.0.0.0", 2021, EM::FTPD::Server, EM::FTPD::Memory::Driver, options)
       EM::Timer.new(0.1) do

data/test/test_memory_filesystem.rb

@@ -11,6 +11,8 @@ require_relative 'helper'
 include EM::FTPD::Memory
 
 class TestMemoryFilesystem < Minitest::Test
+  @@file_size = File.size("test/helper.rb")
+  
   def test_filesystem_instance_retrieval
     fs = FileSystem.getFileSystem(__method__)
     fs2 = FileSystem.getFileSystem(__method__)
@@ -28,7 +30,7 @@ class TestMemoryFilesystem < Minitest::Test
     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"))
+    assert_equal(@@file_size, fs.file_size("/helper.rb"))
     FileSystem.destroyFileSystem(__method__)
   end
   
@@ -39,7 +41,7 @@ class TestMemoryFilesystem < Minitest::Test
     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"))
+    assert_equal(@@file_size, fs.file_size("/helper.rb"))
     assert(fs.delete_file("/helper.rb"))
     refute(fs.exist?("/helper.rb"))
     FileSystem.destroyFileSystem(__method__)
@@ -56,7 +58,7 @@ class TestMemoryFilesystem < Minitest::Test
     
     assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/pub/helper.rb"))
-    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    assert_equal(@@file_size, fs.file_size("/pub/helper.rb"))
     assert(fs.delete_file("/pub/helper.rb"))
     refute(fs.exist?("/pub/helper.rb"))
     FileSystem.destroyFileSystem(__method__)
@@ -72,7 +74,7 @@ class TestMemoryFilesystem < Minitest::Test
     
     assert(fs.create_file("/pub/helper.rb", "test/helper.rb", "root"))
     assert(fs.exist?("/pub/helper.rb"))
-    assert_equal(169, fs.file_size("/pub/helper.rb", "root"))
+    assert_equal(@@file_size, fs.file_size("/pub/helper.rb", "root"))
     refute(fs.delete_dir("/pub", "root"))
     assert(fs.delete_file("/pub/helper.rb", "root"))
     refute(fs.exist?("/pub/helper.rb"))
@@ -91,11 +93,11 @@ class TestMemoryFilesystem < Minitest::Test
     
     assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/pub/helper.rb"))
-    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    assert_equal(@@file_size, fs.file_size("/pub/helper.rb"))
     assert(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"))
+    assert_equal(@@file_size, fs.file_size("/pub/helper.txt"))
     
     FileSystem.destroyFileSystem(__method__)
   end
@@ -114,11 +116,11 @@ class TestMemoryFilesystem < Minitest::Test
     
     assert(fs.create_file("/pub/helper.rb", "test/helper.rb"))
     assert(fs.exist?("/pub/helper.rb"))
-    assert_equal(169, fs.file_size("/pub/helper.rb"))
+    assert_equal(@@file_size, fs.file_size("/pub/helper.rb"))
     assert(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"))
+    assert_equal(@@file_size, fs.file_size("/pub2/helper.txt"))
     
     FileSystem.destroyFileSystem(__method__)
   end
@@ -138,7 +140,7 @@ class TestMemoryFilesystem < Minitest::Test
     assert(fs.exist?("/pub3"))
     refute(fs.is_dir?("/pub3"))
     assert(fs.is_file?("/pub3"))
-    assert_equal(169, fs.file_size("/pub3"))
+    assert_equal(@@file_size, fs.file_size("/pub3"))
     
     refute(fs.rename("/pub", "/pub2"))
     refute(fs.rename("/pub", "/pub3"))
@@ -176,14 +178,14 @@ class TestMemoryFilesystem < Minitest::Test
     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(@@file_size, fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "root"))
 
 
     assert_equal(0, fs.list_files("/pub/pub2/pub3", "jem").length)
     refute(fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "jem"))
     assert(fs.set_owner("/pub/pub2/pub3", "jem", "root"))
     assert_equal(1, fs.list_files("/pub/pub2/pub3", "jem").length)
-    assert_equal(169, fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "jem"))
+    assert_equal(@@file_size, fs.file_size("/pub/pub2/pub3/pub4/helper.rb", "jem"))
 
     assert(fs.set_permissions("/pub/pub2", "rwx......", "root"))
     # jem owns pub3, but should be denied since she can't traverse pub2

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: em-ftpd-memory
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - chrislee35
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-23 00:00:00.000000000 Z
+date: 2015-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-ftpd
@@ -121,7 +121,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Memory-based backing store for em-ftpd