persistable 0.7.0

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.rvmrc
+.yardoc
+doc

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in persistable.gemspec
+gemspec
+gem 'mogilefs-client', '2.2.0'
+gem 'fog'

data/History.txt

@@ -0,0 +1,34 @@
+== 0.5.9 2009-03-06
+
+* 1 major enhancement:
+  * mogile-fs-adapter now opens and closes the connection for every action
+
+== 0.5.7 2009-02-18
+
+* 1 major enhancement:
+  * mogile-fs-adapter can now be given a timeout option
+
+== 0.5.6 2009-01-29
+
+* 1 major enhancement:
+  * mogile-fs-adapter now has the same handling for non-existant keys as the other adapters: returning nil
+
+== 0.5.4 2009-01-29
+
+* 1 minor enhancement:
+  * bumped version for great rebuild
+
+== 0.5.3 2009-01-28
+
+* 1 minor enhancement:
+  * Separated dependencies in dev and runtime dependencies
+
+== 0.5.2 2009-01-28
+
+* 1 major enhancement:
+  * Added missing gem dependencies
+
+== 0.0.1 2009-01-06
+
+* 1 major enhancement:
+  * Initial release

data/README.rdoc

@@ -0,0 +1,64 @@
+= Persistable
+
+== Description
+
+Persistable is a library for persisting IO-Data into any storage you like. It provides adapters for in-memory storage, file storage, mogile-fs storage and a { fog gem }[http://fog.io] powered cloud storage but can be easily extended with your own adapters.
+
+Persistable has been harvested from project pkw.de[http://pkw.de] of { Caroo GmbH }[http://caroo.com].
+
+== Download and Installation
+
+Install the gem with the following command...
+
+  $ gem install persistable --source http://github.com/pkwde/persistable
+
+== Examples
+
+  class Image
+
+    attr_accessor :name, :persistence_adapter
+
+    def initialize(attributes = {})
+      @name = attributes[:name]
+      @persistence_data = attributes[:persistence_data]
+    end
+
+    def persistence_key
+      self.name
+    end
+
+    def persistence_data
+      @persistence_data
+    end
+
+    def persistence_data=(persistence_data)
+      @persistence_data = persistence_data
+    end
+
+    def save_image_data
+      persistence_adapter.write(self)
+    end
+
+    def load_image_data
+      persistence_adapter.load(self)
+    end
+
+  end
+
+
+  image = Image.new(:name => "foo", :persistence_data => File.open("/path/to/foo.jpg"))
+  image.persistence_adapter = Persistable::FSAdapter.new
+  image.save_image_data
+
+  new_but_same_image = Image.new(:name => "foo")
+  new_but_same_image.persistence_adapter = Persistable::FSAdapter.new
+  new_but_same_image.load_image_data
+
+  image.persistence_data == new_but_same_image.persistence_data
+
+
+== License
+
+Copyright Caroo GmbH 2009
+
+You may use, copy and redistribute this library under the same terms as { Ruby itself }[http://www.ruby-lang.org/en/LICENSE.txt] or under the { MIT license }[http://mocha.rubyforge.org/files/MIT-LICENSE.html].

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+
+require 'rake'
+require 'rake/testtask'
+desc "Run unit tests"
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+  t.warning = true
+end

data/lib/persistable.rb

@@ -0,0 +1,13 @@
+require "persistable/version"
+require "persistable/xt/hash"
+
+require "persistable/factory"
+
+##
+# Persistable defines an abstract interface to save, retrieve and delete data from a storage.
+# Currently memory, mogile_fs, file and cloud adapters are supported.
+# The latter is powered by the {http://fog.io/storage/ fog gem}, so any fog storage provider can be used.
+# Persistable has also a {Persistable::Factory factory class}, so you can use it to build your adapter using yml files.
+module Persistable
+
+end

data/lib/persistable/cloud_storage_adapter.rb

@@ -0,0 +1,89 @@
+require "fog"
+
+module Persistable
+  ##
+  # CloudStorageAdapter powered by the fog gem
+  class CloudStorageAdapter
+
+    ##
+    # @!attribute [r] options
+    # @return [Hash] Options used during the object initialization
+    attr_reader :options
+
+    ##
+    # Creates a new `CloudStorageAdapter`
+    # @param options [Hash] `hash` with options for this adapter
+    # @option options [Symbol] :provider One of the providers given
+    #   by {http://http://fog.io/storage/ fog gem}
+    # @option options [String] :directory The directory to save the files to,
+    #   e.g. file system directory, amazon s3 bucket, ...
+    # @option options [Hash] :provider_options Provider options needed
+    #   for {http://http://fog.io/storage/ fog gem} storage providers
+    def initialize(options = {})
+      @options = options
+      available_providers = Fog::Storage.providers
+      available_providers.include?(provider) or raise ArgumentError, "Unknown Fog::Storage provider. Should be on of \
+       #{available_providers.inspect}, given provider"
+      directory_name or raise ArgumentError, "Directory to save file should be given."
+      check_connection
+    end
+
+    ##
+    # Write the data given by `#persisence_data` method to the cloud
+    # @param persistable [#persistance_key, #persistance_data] Any object responding to the methods needed
+    # @return [Boolean] Returns the success status of this operation
+    def write(persistable)
+      if persistable.persistence_data
+        return directory.files.create(:key => persistable.persistence_key, :body => persistable.persistence_data)
+      end
+      return false
+    end
+
+    ##
+    # Reads the data on the cloud and write it on the `persistance_data` property of `persistable` object
+    # @param persistable (@see #write)
+    # @return (@see #write)
+    def read(persistable)
+      if file = directory.files.get(persistable.persistence_key)
+        persistable.persistence_data = StringIO.new(file.body)
+        return true
+      end
+      false
+    end
+
+    ##
+    # Deletes file named `persistable#persistance_key` from storage
+    # @param persistable (@see #write)
+    # @return (@see #write)
+    def delete(persistable)
+      if file = directory.files.head(persistable.persistence_key)
+        return file.destroy
+      end
+      false
+    end
+
+    private
+
+    def connection
+      @connection ||= Fog::Storage.new provider_options
+    end
+    alias check_connection connection
+
+    def directory
+      @directory ||= connection.directories.get(directory_name) || connection.directories.create(:key => directory_name)
+    end
+
+    def directory_name
+      @directory_name ||= options[:directory]
+    end
+
+    def provider
+      @provider ||= options[:provider].to_sym
+    end
+
+    def provider_options
+      options[:provider_options].merge({:provider => options[:provider]}).symbolize_keys
+    end
+
+  end
+end

data/lib/persistable/factory.rb

@@ -0,0 +1,52 @@
+module Persistable
+  ##
+  # Factory class to help to define particular adapters.
+  # @deprecated This class has a strange API, so in the future a new API will be provided
+  class Factory
+
+    ##
+    # Builds a new adapter
+    # @param yml_file_path [String] the path to the config path in yml format.
+    #   This file should include a `Hash` with a key `:adapter`, which is a `Hash` itself.
+    #   The latter hash should contain a field named `type` specifying the adapter type.
+    #   The adapter type is one of ['filesystem', 'mogilefs', 'memory', 'cloud']
+    # @param defaults [Hash={}] Hash with default values for given adapter. Those values will be reverse merged
+    #   with values taken from yml file. The whole method is still useful just because of this param.
+    #   Usually you will specify all values using `defaults` and leaving `yml_file_path` empty.
+    # @return [Adapter] Returns one of the adapter instances specified by the `type` option
+    def self.build(yml_file_path, defaults = {})
+      adapter_config = load_yml(yml_file_path, defaults)
+      raise ArgumentError.new("Invalid Parameter: There should be a Hash with :adapter key.") unless adapter_config[:adapter]
+      adapter_config = adapter_config[:adapter].symbolize_keys
+      raise ArgumentError.new("Invalid Parameter: There should be a Hash with :type key.") unless adapter_config[:type]
+
+      adapter = case adapter_config.delete(:type)
+      when 'filesystem'
+        require "persistable/fs_adapter"
+        Persistable::FSAdapter.new(adapter_config)
+      when 'mogilefs'
+        require "persistable/mogile_fs_adapter"
+        Persistable::MogileFSAdapter.new(adapter_config)
+      when 'memory'
+        require "persistable/memory_adapter"
+        Persistable::MemoryAdapter.new(adapter_config)
+      when 'cloud'
+        require "persistable/cloud_storage_adapter"
+        Persistable::CloudStorageAdapter.new(adapter_config)
+      end
+
+      return adapter
+    end
+
+    ##
+    # Loads the config from a yml file and returns the values as a `Hash`
+    # @param yml_file_path (@see #build)
+    # @param defaults (@see #build)
+    # @return [Hash] options needed to build an adapter
+    def self.load_yml(yml_file_path, defaults = {})
+      defaults.merge!(YAML.load_file(yml_file_path).symbolize_keys) if yml_file_path && File.exists?(yml_file_path)
+      return defaults
+    end
+
+  end
+end

data/lib/persistable/fs_adapter.rb

@@ -0,0 +1,29 @@
+module Persistable
+  class FSAdapter
+    
+    attr_reader :storage_location
+    
+    def initialize(options = {})
+      @storage_location = options[:storage_location] || "/tmp"
+    end
+    
+    def write(persistable)
+      File.open("#{storage_location}/#{persistable.persistence_key}", "w") do |file|
+        file.write persistable.persistence_data.read
+      end
+    end
+    
+    def read(persistable)
+      if File.exists?(path = "#{storage_location}/#{persistable.persistence_key}")
+        persistable.persistence_data = File.open(path)
+      end
+    end
+    
+    def delete(persistable)
+      if File.exists?(path = "#{storage_location}/#{persistable.persistence_key}")
+        File.delete("#{storage_location}/#{persistable.persistence_key}")
+      end
+    end
+    
+  end
+end

data/lib/persistable/memory_adapter.rb

@@ -0,0 +1,23 @@
+module Persistable
+  class MemoryAdapter
+    
+    # Options are not used in this case, but we implement the constructor
+    # header in the same way the other adapters implement it.
+    def initialize(options = {})
+      @storage = {}
+    end
+    
+    def write(persistable)
+      @storage[persistable.persistence_key] = persistable.persistence_data
+    end
+    
+    def read(persistable)
+      persistable.persistence_data = @storage[persistable.persistence_key]
+    end
+    
+    def delete(persistable)
+      @storage.delete(persistable.persistence_key)
+    end
+    
+  end
+end

data/lib/persistable/mogile_fs_adapter.rb

@@ -0,0 +1,53 @@
+require 'mogilefs'
+
+module Persistable
+  class MogileFSAdapter
+    
+    attr_reader :mogile_fs_class, :options
+    
+    
+    def initialize(options = {})
+      @options = options
+      @mogile_fs_class = options[:class]
+    end
+    
+    def write(persistable)
+      hosts = options[:tracker].is_a?(String) ? [options[:tracker]] : options[:tracker]
+      connection = MogileFS::MogileFS.new(:domain => options[:domain], :hosts => hosts, :timeout => options[:timeout] ? options[:timeout] : 10)
+      status = connection.store_file(persistable.persistence_key, mogile_fs_class, persistable.persistence_data)
+      connection.backend.shutdown
+      status
+    end
+    
+    def read(persistable)
+      hosts = options[:tracker].is_a?(String) ? [options[:tracker]] : options[:tracker]
+      connection = MogileFS::MogileFS.new(:domain => options[:domain], :hosts => hosts, :timeout => options[:timeout] ? options[:timeout] : 10)
+      begin
+        if data = connection.get_file_data(persistable.persistence_key)
+          persistable.persistence_data = StringIO.new(data)
+        else
+          persistable.persistence_data = nil
+        end
+      rescue MogileFS::Backend::UnknownKeyError, MogileFS::Backend::NoKeyError => e
+        persistable.persistence_data = nil
+      ensure
+        connection.backend.shutdown
+      end
+    end
+    
+    def delete(persistable)
+      hosts = options[:tracker].is_a?(String) ? [options[:tracker]] : options[:tracker]
+      connection = MogileFS::MogileFS.new(:domain => options[:domain], :hosts => hosts, :timeout => options[:timeout] ? options[:timeout] : 10)
+      begin
+        status = connection.delete(persistable.persistence_key)  
+      rescue MogileFS::Backend::UnknownKeyError => e
+        status = false
+      ensure
+        connection.backend.shutdown
+      end
+
+      status
+    end
+    
+  end
+end

data/lib/persistable/version.rb

@@ -0,0 +1,3 @@
+module Persistable
+  VERSION = "0.7.0"
+end

data/lib/persistable/xt/hash.rb

@@ -0,0 +1,11 @@
+unless ::Hash.method_defined?(:symbolize_keys)
+  class ::Hash
+    def symbolize_keys
+      inject({}) { |hash, (key, value)| hash[key.to_s.to_sym] = value; hash }
+    end
+
+    def symbolize_keys!
+      replace symbolize_keys
+    end
+  end
+end

data/persistable.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "persistable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "persistable"
+  s.version     = Persistable::VERSION
+  s.authors     = ["pkw.de development team"]
+  s.email       = ["dev@pkw.de"]
+  s.homepage    = ""
+  s.summary     = %q{Persistence gem for pkw.de images}
+  s.description = %q{Defines different ways to store images: file, memory, mogile_fs}
+
+  # s.add_dependency "mogilefs-client", "2.2.0"
+  s.add_development_dependency "rake"
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "yard"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/cloud_storage_test.rb

@@ -0,0 +1,91 @@
+require "test_helper"
+
+require 'test_helper'
+require 'persistable/cloud_storage_adapter'
+require 'fileutils'
+
+class CloudStorageTest < Test::Unit::TestCase
+  def test_write_file
+    persistable = get_persistable
+    persistable.persistence_data = File.open(__FILE__)
+    assert adapter.write persistable
+    assert_true File.exist?(file_path)
+  end
+
+  def test_read_file
+    prepare_file
+    persistable = get_persistable
+    assert adapter.read persistable
+    assert persistable.persistence_data
+    assert_equal persistable.persistence_data.read, File.read(file_path)
+  end
+
+  def test_read_not_existent_path
+    assert_nothing_raised do
+      delete_file
+      persistable = get_persistable
+      assert_false adapter.read persistable
+      assert_nil persistable.persistence_data
+    end
+  end
+
+  def assert_delete
+    prepare_file
+    persistable = get_persistable
+    assert_true adapter.delete persistable
+    assert_false File.exist?(file_path)
+  end
+
+  def test_initializer_should_check_provider
+    assert_raise ArgumentError do
+      Persistable::CloudStorageAdapter.new(:provider => :now_known_provider)
+    end
+  end
+
+  def test_initializer_should_check_directory_name
+    assert_raise ArgumentError do
+      Persistable::CloudStorageAdapter.new(:provider => :aws)
+    end
+  end
+
+  def test_initializer_should_not_raise_errors_if_all_required_options_given
+    assert_nothing_raised do
+      Persistable::CloudStorageAdapter.new(valid_options)
+    end
+  end
+
+  private
+
+  def get_persistable
+    persistable = PersistableClass.new
+    persistable.persistence_key = "my_file_name"
+    persistable
+  end
+
+  def file_path
+    '/tmp/my_storage_dir/my_file_name'
+  end
+
+  def delete_file
+    FileUtils.rm_f file_path
+  end
+
+  def prepare_file
+    FileUtils.cp __FILE__, file_path
+    assert_true File.exist?(file_path)
+  end
+
+  def adapter
+    Persistable::CloudStorageAdapter.new valid_options
+  end
+
+  def valid_options
+    {
+      :provider => :local,
+      :directory => 'my_storage_dir',
+      :provider_options => {
+        :local_root => '/tmp'
+      }
+    }
+  end
+end

data/test/factory_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+require 'persistable/factory'
+
+class FactoryTest < Test::Unit::TestCase
+
+  def test_should_build_filesystem_adapter_from_yml
+    yml_file_name = "adapter.yml"
+    Persistable::Factory.expects(:load_yml).with(yml_file_name, {}).returns({:adapter => {:type => "filesystem"}})
+    persistable = Persistable::Factory.build(yml_file_name, {})
+    assert_kind_of Persistable::FSAdapter, persistable
+  end
+
+  def test_should_build_memory_adapter_from_yml
+    yml_file_name = "adapter.yml"
+    Persistable::Factory.expects(:load_yml).with(yml_file_name, {}).returns({:adapter => {:type => "memory"}})
+    persistable = Persistable::Factory.build(yml_file_name, {})
+    assert_kind_of Persistable::MemoryAdapter, persistable
+  end
+
+  def test_should_build_mogilefs_adapter_from_yml
+    yml_file_name = "adapter.yml"
+    Persistable::Factory.expects(:load_yml).with(yml_file_name, {}).returns({:adapter => {:type => "mogilefs", :tracker => "tracker1:6001", :class => "foo", :domain => "bar"}})
+    persistable_adapter = mock("persistable_adapter")
+    Persistable::MogileFSAdapter.expects(:new).with({:tracker => "tracker1:6001", :class => "foo", :domain => "bar"}).returns(persistable_adapter)
+    persistable = Persistable::Factory.build(yml_file_name, {})
+    assert_equal persistable_adapter, persistable
+  end
+
+  def test_should_load_yml_from_filename
+    File.expects(:exists?).returns(true)
+    mock_hash = mock("MockHash")
+    mock_hash.expects(:symbolize_keys).returns({})
+    YAML.expects(:load_file).with("adapter.yml").returns(mock_hash)
+    Persistable::Factory.load_yml("adapter.yml")
+  end
+
+  def test_should_just_return_defaults_in_load_yml_if_file_does_not_exist
+    file_mock = mock("File_mock")
+    File.expects(:exists?).returns(false)
+    defaults = mock("Defaults")
+    loaded_config = Persistable::Factory.load_yml("adapter.yml", defaults)
+    assert_equal defaults, loaded_config
+  end
+
+  def test_should_build_adapter_from_defaults
+    defaults = mock("defaults")
+    Persistable::Factory.expects(:load_yml).with(nil, defaults).returns({:adapter => {:type => "memory"}})
+    Persistable::Factory.build(nil, defaults)
+  end
+
+  def test_build_should_raise_exception_if_wrong_parameter
+    Persistable::Factory.expects(:load_yml).with("file_path", {}).returns(:wrong => :hash)
+    assert_raise(ArgumentError) { Persistable::Factory.build("file_path") }
+    Persistable::Factory.expects(:load_yml).with("file_path", {}).returns(:adapter => {:no_type => "but_adapter"})
+    assert_raise(ArgumentError) { Persistable::Factory.build("file_path") }
+  end
+
+  def test_should_build_cloud_storage_adapter_using_yml
+    yml_file_name = "adapter.yml"
+    Persistable::Factory.expects(:load_yml).with(yml_file_name, {}).returns(
+      {:adapter =>
+        {
+          :type => "cloud",
+          :directory => "store_directory",
+          :provider => "local",
+          :provider_options => {
+            :local_root => "/tmp"
+          }
+        }
+      }
+    )
+
+    persistable = Persistable::Factory.build(yml_file_name, {})
+    assert_kind_of Persistable::CloudStorageAdapter, persistable
+  end
+end

data/test/fs_adapter_test.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+require 'persistable/fs_adapter'
+
+class FSAdapterTest < Test::Unit::TestCase
+
+  def test_should_write_persistable_objects
+    adapter = Persistable::FSAdapter.new
+    adapter.expects(:storage_location).returns("/tmp")
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).returns("42")
+    persistable_object.expects(:persistence_data).returns(StringIO.new("The answer to all questions."))
+
+    adapter.write(persistable_object)
+
+    assert File.exists?("/tmp/42")
+    assert_equal "The answer to all questions.", File.open("/tmp/42").read
+  end
+
+  def test_should_read_persistable_objects
+    adapter = Persistable::FSAdapter.new
+    adapter.expects(:storage_location).returns("/tmp")
+
+    File.open("/tmp/just_a_file", "wb") { |file| file.puts "test" }
+    just_a_file = File.open("/tmp/just_a_file")
+    File.expects(:open).with("/tmp/just_a_file").returns(just_a_file)
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).returns("just_a_file")
+    persistable_object.expects(:persistence_data=).with(just_a_file)
+
+    adapter.read(persistable_object)
+  end
+
+  def test_should_not_read_not_existing_persistable_objects
+    adapter = Persistable::FSAdapter.new
+    adapter.expects(:storage_location).at_least_once.returns("/tmp")
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).returns("just_a_not_existing_key")
+    persistable_object.expects(:persistence_data=).never
+
+    adapter.read(persistable_object)
+  end
+
+  def test_should_delete_persistable_objects
+    adapter = Persistable::FSAdapter.new
+    adapter.expects(:storage_location).times(3).returns("/tmp")
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).times(3).returns("42")
+    persistable_object.expects(:persistence_data).returns(StringIO.new("The answer to all questions."))
+
+    adapter.write(persistable_object)
+
+    assert File.exists?("/tmp/42")
+    assert_equal "The answer to all questions.", File.open("/tmp/42").read
+
+    adapter.delete(persistable_object)
+    assert !File.exists?("/tmp/42")
+  end
+
+  def test_should_set_location_for_persisting_data
+    adapter = Persistable::FSAdapter.new(:storage_location => "/custom/location")
+    assert_equal "/custom/location", adapter.storage_location
+  end
+
+  def test_should_have_default_storage_location_set_to_global_tmp_dir
+    adapter = Persistable::FSAdapter.new
+    assert_equal "/tmp", adapter.storage_location
+  end
+
+end

data/test/memory_adapter_test.rb

@@ -0,0 +1,46 @@
+require 'test_helper'
+require 'persistable/memory_adapter'
+
+class MemoryAdapterTest < Test::Unit::TestCase
+
+  def test_should_write_persistable_objects
+    adapter = Persistable::MemoryAdapter.new
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).returns("42")
+    persistable_object.expects(:persistence_data).returns(StringIO.new("The answer to all questions."))
+
+    adapter.write(persistable_object)
+
+    assert_equal "The answer to all questions.", adapter.instance_variable_get("@storage")["42"].read
+  end
+
+  def test_should_read_persistable_objects
+    adapter = Persistable::MemoryAdapter.new
+
+    test_io_object = StringIO.new("The answer to all questions.")
+    adapter.instance_variable_set("@storage", {"42" => test_io_object})
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).returns("42")
+    persistable_object.expects(:persistence_data=).with(test_io_object)
+
+    adapter.read(persistable_object)
+  end
+
+  def test_should_delete_persistable_objects
+    adapter = Persistable::MemoryAdapter.new
+
+    persistable_object = mock("Persistable")
+    persistable_object.expects(:persistence_key).times(2).returns("42")
+    persistable_object.expects(:persistence_data).returns(StringIO.new("The answer to all questions."))
+
+    adapter.write(persistable_object)
+
+    assert_equal "The answer to all questions.", adapter.instance_variable_get("@storage")["42"].read
+
+    adapter.delete(persistable_object)
+    assert !adapter.instance_variable_get("@storage").has_key?("42")
+  end
+
+end

data/test/mogile_fs_adapter_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+require 'persistable/mogile_fs_adapter'
+
+class MogileFSAdapterTest < Test::Unit::TestCase
+
+  def test_should_write_and_read_and_delete_persistable_objects
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => "tracker.test.de:6001", :class => 'devel')
+
+    data_to_persist = StringIO.new("The answer to all questions.")
+    persistable_object_in = mock("PersistableIn")
+    persistable_object_in.expects(:persistence_key).returns("42")
+    persistable_object_in.expects(:persistence_data).returns(data_to_persist)
+
+    connection_in = mock("MogileFS-Connection")
+    connection_in.expects(:store_file).with("42", "devel", data_to_persist)
+    connection_in.expects(:backend).returns(mock("MockBackend", :shutdown => true))
+    MogileFS::MogileFS.expects(:new).at_least_once.with(:domain => "mydomain", :hosts => ["tracker.test.de:6001"], :timeout => 10).returns(connection_in)
+
+    adapter.write(persistable_object_in)
+
+    persistable_object_out = mock("PersistableOut")
+    persistable_object_out.expects(:persistence_key).returns("42")
+    persistable_object_out.expects(:persistence_data=).with() { |data| data.kind_of? StringIO }
+
+    connection_out = mock("MogileFS-Connection")
+    connection_out.expects(:get_file_data).with("42").returns(data_to_persist.read)
+    connection_out.expects(:backend).returns(mock("MockBackend", :shutdown => true))
+    MogileFS::MogileFS.expects(:new).at_least_once.with(:domain => "mydomain", :hosts => ["tracker.test.de:6001"], :timeout => 10).returns(connection_out)
+
+    adapter.read(persistable_object_out)
+
+    persistable_object_delete = mock("PersistableOut")
+    persistable_object_delete.expects(:persistence_key).returns("42")
+
+    connection_delete = mock("MogileFS-Connection")
+    connection_delete.expects(:delete).with("42")
+    connection_delete.expects(:backend).returns(mock("MockBackend", :shutdown => true))
+    MogileFS::MogileFS.expects(:new).at_least_once.with(:domain => "mydomain", :hosts => ["tracker.test.de:6001"], :timeout => 10).returns(connection_delete)
+
+    adapter.delete(persistable_object_delete)
+  end
+
+  def test_should_set_domain_tracker_and_class
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => "tracker.test.de:6001", :class => 'devel')
+    assert_equal "devel", adapter.mogile_fs_class
+  end
+
+  def test_should_set_domain_multiple_tracker_and_class
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => ["tracker1.test.de:6001", "tracker2.test.com:6001"], :class => 'devel')
+    assert_equal "devel", adapter.mogile_fs_class
+  end
+
+  def test_should_set_timeout
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => "tracker.test.de:6001", :class => 'devel', :timeout => 10)
+    assert_equal "devel", adapter.mogile_fs_class
+  end
+
+  def test_should_handle_unknown_key_on_delete_gracefully
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => "tracker.test.de:6001", :class => 'devel')
+    connection_delete = mock("MogileFS-Connection")
+    persistable_object_delete = mock("PersistableOut")
+    persistable_object_delete.expects(:persistence_key).returns("42")
+    connection_delete.expects(:delete).raises(MogileFS::Backend::UnknownKeyError)
+    connection_delete.expects(:backend).returns(mock("MockBackend", :shutdown => true))
+    MogileFS::MogileFS.expects(:new).at_least_once.with(:domain => "mydomain", :hosts => ["tracker.test.de:6001"], :timeout => 10).returns(connection_delete)
+
+    assert_equal(false, adapter.delete(persistable_object_delete))
+  end
+
+  def test_should_handle_unknown_key_on_read_gracefully
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => "tracker.test.de:6001", :class => 'devel')
+    connection_delete = mock("MogileFS-Connection")
+    persistable_object_read = mock("PersistableOut")
+    persistable_object_read.expects(:persistence_key).returns("42")
+    persistable_object_read.expects(:persistence_data=).with(nil)
+    connection_delete.expects(:get_file_data).raises(MogileFS::Backend::UnknownKeyError)
+    connection_delete.expects(:backend).returns(mock("MockBackend", :shutdown => true))
+    MogileFS::MogileFS.expects(:new).at_least_once.with(:domain => "mydomain", :hosts => ["tracker.test.de:6001"], :timeout => 10).returns(connection_delete)
+
+    assert_nothing_raised(MogileFS::Backend::UnknownKeyError) { adapter.read(persistable_object_read) }
+  end
+
+  def test_should_return_nil_if_file_was_not_found
+    adapter = Persistable::MogileFSAdapter.new(:domain => "mydomain", :tracker => "tracker.test.de:6001", :class => 'devel')
+
+
+    persistable_object_out = mock("PersistableOut")
+    persistable_object_out.expects(:persistence_key).returns("42")
+    persistable_object_out.expects(:persistence_data=).with(nil)
+
+    connection_out = mock("MogileFS-Connection")
+    connection_out.expects(:get_file_data).with("42").returns(nil)
+    connection_out.expects(:backend).returns(mock("MockBackend", :shutdown => true))
+    MogileFS::MogileFS.expects(:new).with(:domain => "mydomain", :hosts => ["tracker.test.de:6001"], :timeout => 10).returns(connection_out)
+    adapter.read(persistable_object_out)
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha/setup'
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require 'persistable'
+
+class PersistableClass
+  attr_accessor :persistence_data, :persistence_key
+end

metadata

@@ -0,0 +1,146 @@
+--- !ruby/object:Gem::Specification 
+name: persistable
+version: !ruby/object:Gem::Version 
+  hash: 3
+  prerelease: 
+  segments: 
+  - 0
+  - 7
+  - 0
+  version: 0.7.0
+platform: ruby
+authors: 
+- pkw.de development team
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-02-07 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: test-unit
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id003
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: yard
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id004
+  prerelease: false
+description: "Defines different ways to store images: file, memory, mogile_fs"
+email: 
+- dev@pkw.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- History.txt
+- README.rdoc
+- Rakefile
+- lib/persistable.rb
+- lib/persistable/cloud_storage_adapter.rb
+- lib/persistable/factory.rb
+- lib/persistable/fs_adapter.rb
+- lib/persistable/memory_adapter.rb
+- lib/persistable/mogile_fs_adapter.rb
+- lib/persistable/version.rb
+- lib/persistable/xt/hash.rb
+- persistable.gemspec
+- test/cloud_storage_test.rb
+- test/factory_test.rb
+- test/fs_adapter_test.rb
+- test/memory_adapter_test.rb
+- test/mogile_fs_adapter_test.rb
+- test/test_helper.rb
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Persistence gem for pkw.de images
+test_files: 
+- test/cloud_storage_test.rb
+- test/factory_test.rb
+- test/fs_adapter_test.rb
+- test/memory_adapter_test.rb
+- test/mogile_fs_adapter_test.rb
+- test/test_helper.rb
+has_rdoc: