hammerspace-fork 0.1.5.1

data/spec/lib/hammerspace/backend/sparkey_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Hammerspace::Backend::Sparkey do
+
+  let(:path) { HAMMERSPACE_ROOT }
+  let(:options) { {} }
+
+  before do
+    FileUtils.rm_rf(path, :secure => true)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(path, :secure => true)
+  end
+
+  it "creates path on set" do
+    hash = Hammerspace.new(path, options)
+    hash['foo'] = 'bar'
+    hash.close
+
+    Dir.exist?(path).should be_true
+  end
+
+  it "bulks writes" do
+    Gnista::Hash.should_receive(:write).once.and_call_original
+
+    hash = Hammerspace.new(path, options)
+    hash['foo'] = 'bar'
+    hash['foo'] = 'newvalue'
+    hash.close
+  end
+
+  it "handles high write concurrency and cleans up" do
+    run_write_concurrency_test(path, options)
+
+    # Also, at the end of the test, there should be one directory and one symlink.
+    SparkeyDirectoryHelper.directory_count(path).should == 1
+    SparkeyDirectoryHelper.has_current_symlink?(path).should be_true
+    SparkeyDirectoryHelper.has_unknown_files?(path).should be_false
+  end
+
+  describe "#check_fs" do
+
+    it "should call check methods" do
+      Hammerspace::Backend::Sparkey.any_instance.should_receive(:flock_works?).once.and_call_original
+      Hammerspace::Backend::Sparkey.any_instance.should_receive(:dir_cleanup_works?).once.and_call_original
+
+      Hammerspace.new(path, options)
+    end
+
+  end
+
+  describe "#flock_works?" do
+
+    it "should check flock and return true" do
+      Hammerspace.new(path, options).backend.flock_works?.should be_true
+    end
+
+  end
+
+  describe "#dir_cleanup_works?" do
+
+    it "should check directory cleanup and return true" do
+      Hammerspace.new(path, options).backend.dir_cleanup_works?.should be_true
+    end
+
+  end
+
+  describe "#clear" do
+
+    it "removes all keys and values and cleans up" do
+      hash = Hammerspace.new(path, options)
+      hash['foo'] = 'bar'
+      hash.close
+
+      hash = Hammerspace.new(path, options)
+      hash.clear
+      hash['foo'].should be_nil
+      hash.size.should == 0
+      hash.close
+
+      SparkeyDirectoryHelper.directory_count(path).should == 0
+      SparkeyDirectoryHelper.has_current_symlink?(path).should be_false
+    end
+
+    it "removes unflushed keys and values and cleans up" do
+      hash = Hammerspace.new(path, options)
+      hash['foo'] = 'bar'
+      hash.clear
+      hash['foo'].should be_nil
+      hash.size.should == 0
+      hash.close
+
+      SparkeyDirectoryHelper.directory_count(path).should == 0
+      SparkeyDirectoryHelper.has_current_symlink?(path).should be_false
+    end
+
+  end
+
+  describe "#close" do
+
+    it "removes empty directories" do
+      writer1 = Hammerspace.new(path, options)
+      writer1['foo'] = 'bar'
+      writer1.close
+
+      reader = Hammerspace.new(path, options)
+      reader['foo'].should == 'bar'
+
+      writer2 = Hammerspace.new(path, options)
+      writer2['foo'] = 'bar'
+      writer2.close
+
+      SparkeyDirectoryHelper.directory_count(path).should == 1
+
+      reader.close
+
+      SparkeyDirectoryHelper.directory_count(path).should == 1
+    end
+
+  end
+
+  describe "#each" do
+
+    it "removes empty directories after iteration with block" do
+      writer1 = Hammerspace.new(path, options)
+      writer1['foo'] = 'bar'
+      writer1.close
+
+      reader = Hammerspace.new(path, options)
+      reader.each do |key,value|
+        writer2 = Hammerspace.new(path, options)
+        writer2['foo'] = 'bar'
+        writer2.close
+
+        SparkeyDirectoryHelper.directory_count(path).should == 1
+      end
+
+      SparkeyDirectoryHelper.directory_count(path).should == 1
+
+      reader.close
+    end
+
+    it "removes empty directories after iteration with enumerator" do
+      writer1 = Hammerspace.new(path, options)
+      writer1['foo'] = 'bar'
+      writer1.close
+
+      reader = Hammerspace.new(path, options)
+      reader.each.map do |key,value|
+        writer2 = Hammerspace.new(path, options)
+        writer2['foo'] = 'bar'
+        writer2.close
+
+        SparkeyDirectoryHelper.directory_count(path).should == 1
+      end
+
+      SparkeyDirectoryHelper.directory_count(path).should == 1
+
+      reader.close
+    end
+
+  end
+
+  describe "#include?" do
+
+    it "calls has_key?" do
+      Gnista::Hash.any_instance.should_receive(:include?).once.and_call_original
+
+      hash = Hammerspace.new(path, options)
+      hash['foo'] = 'bar'
+      hash.include?('foo').should be_true
+      hash.close
+    end
+
+  end
+
+  describe "#member?" do
+
+    it "calls has_key?" do
+      Gnista::Hash.any_instance.should_receive(:include?).once.and_call_original
+
+      hash = Hammerspace.new(path, options)
+      hash['foo'] = 'bar'
+      hash.member?('foo').should be_true
+      hash.close
+    end
+
+  end
+
+end

data/spec/lib/hammerspace/hash_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Hammerspace::Hash do
+
+  let(:path) { HAMMERSPACE_ROOT }
+  let(:options) { {} }
+
+  before do
+    FileUtils.rm_rf(path, :secure => true)
+  end
+
+  after(:all) do
+    FileUtils.rm_rf(path, :secure => true)
+  end
+
+  describe "#initialize" do
+
+    it "creates the backend" do
+      hash = Hammerspace::Hash.new(path, options)
+      hash.backend.should be_a_kind_of(Hammerspace::Backend::Base)
+    end
+
+    it "takes a third argument and sets default" do
+      hash = Hammerspace::Hash.new(path, options, 'default')
+      hash.default.should == 'default'
+    end
+
+    it "takes a block and sets default_proc" do
+      hash = Hammerspace::Hash.new(path, options) { |h,k| k }
+      hash.default_proc.should be_an_instance_of(Proc)
+    end
+
+    it "raises ArgumentError if both third argument and block are passed" do
+      expect {
+        Hammerspace::Hash.new(path, options, 'default') { |h,k| k }
+      }.to raise_error(ArgumentError)
+    end
+
+    it "raises ArgumentError if a fourth argument is passed" do
+      expect {
+        Hammerspace::Hash.new(path, options, 'default', 'bogus')
+      }.to raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "#default=" do
+
+    it "sets default" do
+      hash = Hammerspace::Hash.new(path, options)
+      hash.default = 'bar'
+      hash.default.should == 'bar'
+    end
+
+    it "unsets default_proc" do
+      hash = Hammerspace::Hash.new(path, options)
+      hash.default_proc = lambda { |h,k| k }
+      hash.default = 'bar'
+      hash.default_proc.should be_nil
+    end
+
+  end
+
+  describe "#default_proc=" do
+
+    it "sets default_proc" do
+      p = lambda { |h,k| k }
+      hash = Hammerspace::Hash.new(path, options)
+      hash.default_proc = p
+      hash.default_proc.should == p
+    end
+
+    it "unsets default" do
+      hash = Hammerspace::Hash.new(path, options)
+      hash.default = 'bar'
+      hash.default_proc = p
+      hash.default('foo').should be_nil
+    end
+
+  end
+
+  describe "#default" do
+
+    context "with default set" do
+
+      context "with an argument" do
+
+        it "returns default value" do
+          hash = Hammerspace::Hash.new(path, options)
+          hash.default = 'bar'
+          hash.default('foo').should == 'bar'
+        end
+
+      end
+
+      context "without an argument" do
+
+        it "returns default value" do
+          hash = Hammerspace::Hash.new(path, options)
+          hash.default = 'bar'
+          hash.default('foo').should == 'bar'
+        end
+
+      end
+
+    end
+
+    context "with default_proc set" do
+
+      context "with an argument" do
+
+        it "evaluates proc" do
+          hash = Hammerspace::Hash.new(path, options) do |h,k|
+            h.should == hash
+            k.reverse
+          end
+          hash.default('foo').should == 'oof'
+        end
+
+      end
+
+      context "without an argument" do
+
+        it "returns nil" do
+          hash = Hammerspace::Hash.new(path, options) { |h,k| k }
+          hash.default.should be_nil
+        end
+
+      end
+
+    end
+
+  end
+
+  it "supports enumerable" do
+    hash = Hammerspace::Hash.new(path, options)
+    hash['a'] = 'A'
+    hash['b'] = 'B'
+    result = hash.map { |key,value| key + value }
+    result.should == ['aA', 'bB']
+  end
+
+end

data/spec/lib/hammerspace_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Hammerspace do
+
+  let(:path) { HAMMERSPACE_ROOT }
+  let(:options) { {} }
+
+  describe "#initialize" do
+
+    it "returns a Hammerspace::Hash object" do
+      hash = Hammerspace.new(path, options)
+      hash.should be_an_instance_of(Hammerspace::Hash)
+    end
+
+    it "takes a third argument and sets default" do
+      hash = Hammerspace.new(path, options, 'default')
+      hash.default.should == 'default'
+    end
+
+    it "takes a block and sets default_proc" do
+      hash = Hammerspace::Hash.new(path, options) { |h,k| k }
+      hash.default_proc.should be_an_instance_of(Proc)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+SimpleCov.use_merging false
+
+# from https://gist.github.com/clicube/5017378
+pid = Process.pid
+SimpleCov.at_exit do
+  SimpleCov.result.format! if Process.pid == pid
+end
+
+require 'hammerspace'
+
+require 'support/sparkey_directory_helper'
+require 'support/write_concurrency_test'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.include(WriteConcurrencyTest)
+end
+
+HAMMERSPACE_ROOT = ENV['HAMMERSPACE_ROOT'] || 'tmp'
+warn "Temporary hammerspace files will be written to #{HAMMERSPACE_ROOT}"

data/spec/support/sparkey_directory_helper.rb

@@ -0,0 +1,26 @@
+module SparkeyDirectoryHelper
+
+  def self.directory_count(path)
+    dirs = 0
+    Dir.glob(File.join(path, '*')) do |f|
+      dirs += 1 if File.directory?(f) && !File.symlink?(f)
+    end
+    dirs
+  end
+
+  def self.has_current_symlink?(path)
+    File.symlink?(File.join(path, 'current'))
+  end
+
+  def self.has_unknown_files?(path)
+    unknown_files = false
+    Dir.glob(File.join(path, '*')) do |file|
+      next if File.directory?(file)
+      next if File.basename(file) == 'current' && File.symlink?(file)
+      next if File.basename(file) == 'hammerspace.lock' && File.file?(file)
+      unknown_files = true
+    end
+    unknown_files
+  end
+
+end

data/spec/support/write_concurrency_test.rb

@@ -0,0 +1,38 @@
+module WriteConcurrencyTest
+
+  # Initialize n hashes (of joyful nonsense), fork one process for each. Have
+  # them madly write their hash, and flush (repeat many, many times). While
+  # this is happening, read from the hammerspace. It should contain one of the
+  # n original hashes. Though which one I shall never tell.
+  def run_write_concurrency_test(path, options, concurrency = 10, iterations = 10, size = 10)
+    pids = []
+
+    concurrency.times do |id|
+      pids << fork do
+        iterations.times do
+          hash = Hammerspace.new(path, options)
+          size.times { |i| hash[i.to_s] = id.to_s }
+          hash.close
+        end
+      end
+    end
+
+    # Wait for first hash to be written, otherwise our hash.size expectations will fail.
+    sleep(0.5)
+
+    iterations.times do
+      hash = Hammerspace.new(path, options)
+      hash_size = hash.size
+      raise "hash.size == #{hash_size}, expected #{size}" unless hash_size == size
+      size.times do |i|
+        unless hash[i.to_s] == hash['0']
+          raise "hash[#{i.to_s}] == #{hash[i.to_s]}, expected #{hash['0']}"
+        end
+      end
+      hash.close
+    end
+
+    pids.each { |pid| Process.wait(pid) }
+  end
+
+end