fluentd 0.12.43 → 0.14.0

data/test/plugin/test_output_as_standard.rb

@@ -0,0 +1,362 @@
+require_relative '../helper'
+require 'fluent/plugin/output'
+require 'fluent/plugin/buffer'
+require 'fluent/msgpack_factory'
+require 'fluent/event'
+
+require 'json'
+require 'time'
+require 'timeout'
+
+require 'flexmock/test_unit'
+
+module FluentPluginStandardBufferedOutputTest
+  class DummyBareOutput < Fluent::Plugin::Output
+    def register(name, &block)
+      instance_variable_set("@#{name}", block)
+    end
+  end
+  class DummyAsyncOutput < DummyBareOutput
+    def format(tag, time, record)
+      @format ? @format.call(tag, time, record) : [tag, time, record].to_json
+    end
+    def write(chunk)
+      @write ? @write.call(chunk) : nil
+    end
+  end
+  class DummyAsyncStandardOutput < DummyBareOutput
+    def write(chunk)
+      @write ? @write.call(chunk) : nil
+    end
+  end
+end
+
+class StandardBufferedOutputTest < Test::Unit::TestCase
+  def create_output(type=:full)
+    case type
+    when :bare     then FluentPluginStandardBufferedOutputTest::DummyBareOutput.new
+    when :buffered then FluentPluginStandardBufferedOutputTest::DummyAsyncOutput.new
+    when :standard then FluentPluginStandardBufferedOutputTest::DummyAsyncStandardOutput.new
+    else
+      raise ArgumentError, "unknown type: #{type}"
+    end
+  end
+  def create_metadata(timekey: nil, tag: nil, variables: nil)
+    Fluent::Plugin::Buffer::Metadata.new(timekey, tag, variables)
+  end
+  def waiting(seconds)
+    begin
+      Timeout.timeout(seconds) do
+        yield
+      end
+    rescue Timeout::Error
+      STDERR.print(*@i.log.out.logs)
+      raise
+    end
+  end
+  def test_event_stream
+    es = Fluent::MultiEventStream.new
+    es.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+    es.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+    es.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+    es.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+    es.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+    es.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+    es
+  end
+
+  setup do
+    @i = nil
+  end
+
+  teardown do
+    if @i
+      @i.stop unless @i.stopped?
+      @i.before_shutdown unless @i.before_shutdown?
+      @i.shutdown unless @i.shutdown?
+      @i.after_shutdown unless @i.after_shutdown?
+      @i.close unless @i.closed?
+      @i.terminate unless @i.terminated?
+    end
+  end
+
+  sub_test_case 'standard buffered without any chunk keys' do
+    test '#execute_chunking calls @buffer.write(bulk: true) just once with predefined msgpack format' do
+      @i = create_output(:standard)
+      @i.configure(config_element())
+      @i.start
+
+      m = create_metadata()
+      es = test_event_stream
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({m => [es.to_msgpack_stream, es.size]}, bulk: true, enqueue: false)
+
+      @i.execute_chunking("mytag.test", es)
+    end
+
+    test '#execute_chunking calls @buffer.write(bulk: true) just once with predefined msgpack format, but time will be int if time_as_integer specified' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{"time_as_integer"=>"true"}))
+      @i.start
+
+      m = create_metadata()
+      es = test_event_stream
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({m => [es.to_msgpack_stream(time_int: true), es.size]}, bulk: true, enqueue: false)
+
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+
+  sub_test_case 'standard buffered with tag chunk key' do
+    test '#execute_chunking calls @buffer.write(bulk: true) just once with predefined msgpack format' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{},[config_element('buffer','tag',{'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m = create_metadata(tag: "mytag.test")
+      es = test_event_stream
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({m => [es.to_msgpack_stream, es.size]}, bulk: true, enqueue: false)
+
+      @i.execute_chunking("mytag.test", es)
+    end
+
+    test '#execute_chunking calls @buffer.write(bulk: true) just once with predefined msgpack format, but time will be int if time_as_integer specified' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{"time_as_integer"=>"true"},[config_element('buffer','tag',{'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m = create_metadata(tag: "mytag.test")
+      es = test_event_stream
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({m => [es.to_msgpack_stream(time_int: true), es.size]}, bulk: true, enqueue: false)
+
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+
+  sub_test_case 'standard buffered with time chunk key' do
+    test '#execute_chunking calls @buffer.write(bulk: true) with predefined msgpack format' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{},[config_element('buffer','time',{"timekey" => "60",'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m1 = create_metadata(timekey: Time.parse('2016-04-21 17:19:00 -0700').to_i)
+      m2 = create_metadata(timekey: Time.parse('2016-04-21 17:20:00 -0700').to_i)
+      m3 = create_metadata(timekey: Time.parse('2016-04-21 17:21:00 -0700').to_i)
+
+      es1 = Fluent::MultiEventStream.new
+      es1.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      es2 = Fluent::MultiEventStream.new
+      es2.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es2.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      es3 = Fluent::MultiEventStream.new
+      es3.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({
+          m1 => [es1.to_msgpack_stream, 3],
+          m2 => [es2.to_msgpack_stream, 2],
+          m3 => [es3.to_msgpack_stream, 1],
+        }, bulk: true, enqueue: false)
+
+      es = test_event_stream
+      @i.execute_chunking("mytag.test", es)
+    end
+
+    test '#execute_chunking calls @buffer.write(bulk: true) with predefined msgpack format, but time will be int if time_as_integer specified' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{"time_as_integer" => "true"},[config_element('buffer','time',{"timekey" => "60",'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m1 = create_metadata(timekey: Time.parse('2016-04-21 17:19:00 -0700').to_i)
+      m2 = create_metadata(timekey: Time.parse('2016-04-21 17:20:00 -0700').to_i)
+      m3 = create_metadata(timekey: Time.parse('2016-04-21 17:21:00 -0700').to_i)
+
+      es1 = Fluent::MultiEventStream.new
+      es1.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      es2 = Fluent::MultiEventStream.new
+      es2.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es2.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      es3 = Fluent::MultiEventStream.new
+      es3.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).with({
+          m1 => [es1.to_msgpack_stream(time_int: true), 3],
+          m2 => [es2.to_msgpack_stream(time_int: true), 2],
+          m3 => [es3.to_msgpack_stream(time_int: true), 1],
+        }, bulk: true, enqueue: false)
+
+      es = test_event_stream
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+
+  sub_test_case 'standard buffered with variable chunk keys' do
+    test '#execute_chunking calls @buffer.write(bulk: true) with predefined msgpack format' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{},[config_element('buffer','key,name',{'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m1 = create_metadata(variables: {key: "my value", name: "moris1"})
+      es1 = Fluent::MultiEventStream.new
+      es1.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      m2 = create_metadata(variables: {key: "my value", name: "moris2"})
+      es2 = Fluent::MultiEventStream.new
+      es2.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).with({
+          m1 => [es1.to_msgpack_stream, 5],
+          m2 => [es2.to_msgpack_stream, 1],
+        }, bulk: true, enqueue: false).once
+
+      es = test_event_stream
+      @i.execute_chunking("mytag.test", es)
+    end
+
+    test '#execute_chunking calls @buffer.write(bulk: true) in times of # of variable variations with predefined msgpack format, but time will be int if time_as_integer specified' do
+      @i = create_output(:standard)
+      @i.configure(config_element('ROOT','',{"time_as_integer" => "true"},[config_element('buffer','key,name',{'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m1 = create_metadata(variables: {key: "my value", name: "moris1"})
+      es1 = Fluent::MultiEventStream.new
+      es1.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      m2 = create_metadata(variables: {key: "my value", name: "moris2"})
+      es2 = Fluent::MultiEventStream.new
+      es2.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).with({
+          m1 => [es1.to_msgpack_stream(time_int: true), 5],
+          m2 => [es2.to_msgpack_stream(time_int: true), 1],
+        }, bulk: true, enqueue: false).once
+
+      es = test_event_stream
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+
+  sub_test_case 'custom format buffered without any chunk keys' do
+    test '#execute_chunking calls @buffer.write(bulk: true) just once with customized format' do
+      @i = create_output(:buffered)
+      @i.register(:format){|tag, time, record| [time, record].to_json }
+      @i.configure(config_element())
+      @i.start
+
+      m = create_metadata()
+      es = test_event_stream
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({m => [es.map{|t,r| [t,r].to_json }.join, es.size]}, bulk: true, enqueue: false)
+
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+
+  sub_test_case 'custom format buffered with tag chunk key' do
+    test '#execute_chunking calls @buffer.write(bulk: true) just once with customized format' do
+      @i = create_output(:buffered)
+      @i.register(:format){|tag, time, record| [time, record].to_json }
+      @i.configure(config_element('ROOT','',{},[config_element('buffer','tag',{'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m = create_metadata(tag: "mytag.test")
+      es = test_event_stream
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).once.with({m => [es.map{|t,r| [t,r].to_json }.join, es.size]}, bulk: true, enqueue: false)
+
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+  sub_test_case 'custom format buffered with time chunk key' do
+    test '#execute_chunking calls @buffer.write with customized format' do
+      @i = create_output(:buffered)
+      @i.register(:format){|tag, time, record| [time, record].to_json }
+      @i.configure(config_element('ROOT','',{},[config_element('buffer','time',{"timekey" => "60",'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m1 = create_metadata(timekey: Time.parse('2016-04-21 17:19:00 -0700').to_i)
+      m2 = create_metadata(timekey: Time.parse('2016-04-21 17:20:00 -0700').to_i)
+      m3 = create_metadata(timekey: Time.parse('2016-04-21 17:21:00 -0700').to_i)
+
+      es1 = Fluent::MultiEventStream.new
+      es1.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      es2 = Fluent::MultiEventStream.new
+      es2.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es2.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      es3 = Fluent::MultiEventStream.new
+      es3.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).with({
+          m1 => es1.map{|t,r| [t,r].to_json },
+          m2 => es2.map{|t,r| [t,r].to_json },
+          m3 => es3.map{|t,r| [t,r].to_json },
+        }, bulk: false, enqueue: false).once
+
+      es = test_event_stream
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+
+  sub_test_case 'custom format buffered with variable chunk keys' do
+    test '#execute_chunking calls @buffer.write in times of # of variable variations with customized format' do
+      @i = create_output(:buffered)
+      @i.register(:format){|tag, time, record| [time, record].to_json }
+      @i.configure(config_element('ROOT','',{},[config_element('buffer','key,name',{'flush_thread_burst_interval' => 0.01})]))
+      @i.start
+
+      m1 = create_metadata(variables: {key: "my value", name: "moris1"})
+      es1 = Fluent::MultiEventStream.new
+      es1.add(event_time('2016-04-21 17:19:00 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:19:25 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:20:01 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:20:13 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+      es1.add(event_time('2016-04-21 17:21:32 -0700'), {"key" => "my value", "name" => "moris1", "message" => "hello!"})
+
+      m2 = create_metadata(variables: {key: "my value", name: "moris2"})
+      es2 = Fluent::MultiEventStream.new
+      es2.add(event_time('2016-04-21 17:19:13 -0700'), {"key" => "my value", "name" => "moris2", "message" => "hello!"})
+
+      buffer_mock = flexmock(@i.buffer)
+      buffer_mock.should_receive(:write).with({
+          m1 => es1.map{|t,r| [t,r].to_json },
+          m2 => es2.map{|t,r| [t,r].to_json },
+        }, bulk: false, enqueue: false).once
+
+      es = test_event_stream
+      @i.execute_chunking("mytag.test", es)
+    end
+  end
+end

data/test/plugin/test_owned_by.rb

@@ -0,0 +1,35 @@
+require_relative '../helper'
+require 'fluent/plugin/base'
+require 'fluent/plugin/input'
+require 'fluent/plugin/owned_by_mixin'
+
+module OwnedByMixinTestEnv
+  class DummyParent < Fluent::Plugin::Input
+    Fluent::Plugin.register_input('dummy_parent', self)
+  end
+  class DummyChild < Fluent::Plugin::Base
+    include Fluent::Plugin::OwnedByMixin
+    Fluent::Plugin.register_parser('dummy_child', self)
+  end
+end
+
+class OwnedByMixinTest < Test::Unit::TestCase
+  sub_test_case 'Owned plugins' do
+    setup do
+      Fluent::Test.setup
+    end
+
+    test 'inherits plugin id and logger from parent' do
+      parent = Fluent::Plugin.new_input('dummy_parent')
+      parent.configure(config_element('ROOT', '', {'@id' => 'my_parent_id', '@log_level' => 'trace'}))
+      child = Fluent::Plugin.new_parser('dummy_child', parent: parent)
+
+      assert_equal parent.object_id, child.owner.object_id
+
+      assert child.instance_eval{ @_plugin_id_configured }
+      assert_equal 'my_parent_id', child.instance_eval{ @_plugin_id }
+
+      assert_equal Fluent::Log::LEVEL_TRACE, child.log.level
+    end
+  end
+end

data/test/plugin/test_storage.rb

@@ -0,0 +1,167 @@
+require_relative '../helper'
+require 'fluent/plugin/storage'
+require 'fluent/plugin/base'
+
+class DummyPlugin < Fluent::Plugin::TestBase
+end
+
+class BareStorage < Fluent::Plugin::Storage
+  Fluent::Plugin.register_storage('bare', self)
+end
+
+class BasicStorage < Fluent::Plugin::Storage
+  Fluent::Plugin.register_storage('example', self)
+
+  attr_reader :data, :saved
+
+  def initialize
+    super
+    @data = @saved = nil
+  end
+  def load
+    @data = {}
+  end
+  def save
+    @saved = @data.dup
+  end
+  def get(key)
+    @data[key]
+  end
+  def fetch(key, defval)
+    @data.fetch(key, defval)
+  end
+  def put(key, value)
+    @data[key] = value
+  end
+  def delete(key)
+    @data.delete(key)
+  end
+  def update(key, &block)
+    @data[key] = block.call(@data[key])
+  end
+  def close
+    @data = {}
+    super
+  end
+  def terminate
+    @saved = {}
+    super
+  end
+end
+
+class StorageTest < Test::Unit::TestCase
+  sub_test_case 'BareStorage' do
+    setup do
+      plugin = DummyPlugin.new
+      @s = BareStorage.new
+      @s.configure(config_element())
+      @s.owner = plugin
+    end
+
+    test 'is configured with plugin information and system config' do
+      plugin = DummyPlugin.new
+      plugin.system_config_override({'process_name' => 'mytest'})
+      plugin.configure(config_element('ROOT', '', {'@id' => '1'}))
+      s = BareStorage.new
+      s.configure(config_element())
+      s.owner = plugin
+
+      assert_equal 'mytest', s.owner.system_config.process_name
+      assert_equal '1', s.instance_eval{ @_plugin_id }
+      assert_equal true, s.instance_eval{ @_plugin_id_configured }
+    end
+
+    test 'does NOT have features for high-performance/high-consistent storages' do
+      assert_equal false, @s.persistent_always?
+      assert_equal false, @s.synchronized?
+    end
+
+    test 'does have default values which is conservative for almost all users' do
+      assert_equal false, @s.persistent
+      assert_equal true, @s.autosave
+      assert_equal 10,   @s.autosave_interval
+      assert_equal true, @s.save_at_shutdown
+    end
+
+    test 'load/save doesn NOT anything: just as memory storage' do
+      assert_nothing_raised{ @s.load }
+      assert_nothing_raised{ @s.save }
+    end
+
+    test 'all operations are not defined yet' do
+      assert_raise NotImplementedError do
+        @s.get('key')
+      end
+      assert_raise NotImplementedError do
+        @s.fetch('key', 'value')
+      end
+      assert_raise NotImplementedError do
+        @s.put('key', 'value')
+      end
+      assert_raise NotImplementedError do
+        @s.delete('key')
+      end
+      assert_raise NotImplementedError do
+        @s.update('key'){ |v| v + '2' }
+      end
+    end
+  end
+
+  sub_test_case 'ExampleStorage' do
+    setup do
+      plugin = DummyPlugin.new
+      plugin.configure(config_element('ROOT', '', {'@id' => '1'}))
+      @s = BasicStorage.new
+      @s.configure(config_element())
+      @s.owner = plugin
+    end
+
+    test 'load/save works well as plugin internal state operations' do
+      plugin = DummyPlugin.new
+      plugin.configure(config_element('ROOT', '', {'@id' => '0'}))
+      s = BasicStorage.new
+      s.owner = plugin
+
+      assert_nothing_raised{ s.load }
+      assert s.data
+      assert_nil s.saved
+
+      assert_nothing_raised{ s.save }
+      assert s.saved
+      assert{ s.data == s.saved }
+      assert{ s.data.object_id != s.saved.object_id }
+    end
+
+    test 'all operations work well' do
+      @s.load
+
+      assert_nil @s.get('key')
+      assert_equal 'value', @s.fetch('key', 'value')
+      assert_nil @s.get('key')
+
+      assert_equal 'value', @s.put('key', 'value')
+      assert_equal 'value', @s.get('key')
+
+      assert_equal 'valuevalue', @s.update('key'){|v| v * 2 }
+
+      assert_equal 'valuevalue', @s.delete('key')
+    end
+
+    test 'close and terminate work to operate internal states' do
+      @s.load
+      @s.put('k1', 'v1')
+      @s.put('k2', 'v2')
+      assert_equal 2, @s.data.size
+      @s.save
+      assert_equal @s.data.size, @s.saved.size
+
+      assert_nothing_raised{ @s.close }
+      assert @s.data.empty?
+      assert !@s.saved.empty?
+
+      assert_nothing_raised{ @s.terminate }
+      assert @s.data.empty?
+      assert @s.saved.empty?
+    end
+  end
+end