fluentd 0.12.40 → 1.6.2

data/test/plugin/test_formatter_single_value.rb

@@ -0,0 +1,38 @@
+require_relative '../helper'
+require 'fluent/test/driver/formatter'
+require 'fluent/plugin/formatter_single_value'
+
+class SingleValueFormatterTest < ::Test::Unit::TestCase
+  def create_driver(conf = "")
+    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::SingleValueFormatter).configure(conf)
+  end
+
+  def test_config_params
+    d = create_driver
+    assert_equal "message", d.instance.message_key
+  end
+
+  def test_config_params_message_key
+    d = create_driver('message_key' => 'foobar')
+    assert_equal "foobar", d.instance.message_key
+  end
+
+  def test_format
+    d = create_driver
+    formatted = d.instance.format('tag', event_time, {'message' => 'awesome'})
+    assert_equal("awesome\n", formatted)
+  end
+
+  def test_format_without_newline
+    d = create_driver('add_newline' => 'false')
+    formatted = d.instance.format('tag', event_time, {'message' => 'awesome'})
+    assert_equal("awesome", formatted)
+  end
+
+  def test_format_with_message_key
+    d = create_driver('message_key' => 'foobar')
+    formatted = d.instance.format('tag', event_time, {'foobar' => 'foo'})
+
+    assert_equal("foo\n", formatted)
+  end
+end

data/test/plugin/test_formatter_tsv.rb

@@ -0,0 +1,68 @@
+require_relative '../helper'
+require 'fluent/test/driver/formatter'
+require 'fluent/plugin/formatter_tsv'
+
+class TSVFormatterTest < ::Test::Unit::TestCase
+  def setup
+    @time = event_time
+  end
+
+  def create_driver(conf = "")
+    Fluent::Test::Driver::Formatter.new(Fluent::Plugin::TSVFormatter).configure(conf)
+  end
+
+  def tag
+    "tag"
+  end
+
+  def record
+    {'message' => 'awesome', 'greeting' => 'hello'}
+  end
+
+  def test_config_params
+    d = create_driver(
+      'keys' => 'message,greeting',
+    )
+    assert_equal ["message", "greeting"], d.instance.keys
+    assert_equal "\t", d.instance.delimiter
+    assert_equal true, d.instance.add_newline
+
+    d = create_driver(
+      'keys' => 'message,greeting',
+      'delimiter' => ',',
+      'add_newline' => false,
+    )
+    assert_equal ["message", "greeting"], d.instance.keys
+    assert_equal ",", d.instance.delimiter
+    assert_equal false, d.instance.add_newline
+  end
+
+  def test_format
+    d = create_driver(
+      'keys' => 'message,greeting',
+    )
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("awesome\thello\n", formatted)
+  end
+
+  def test_format_without_newline
+    d = create_driver(
+      'keys' => 'message,greeting',
+      'add_newline' => false,
+    )
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("awesome\thello", formatted)
+  end
+
+  def test_format_with_customized_delimiters
+    d = create_driver(
+      'keys' => 'message,greeting',
+      'delimiter' => ',',
+    )
+    formatted = d.instance.format(tag, @time, record)
+
+    assert_equal("awesome,hello\n", formatted)
+  end
+end

data/test/plugin/test_in_debug_agent.rb

@@ -1,4 +1,6 @@
 require_relative '../helper'
+require 'fluent/test/driver/input'
+require 'fluent/plugin/in_debug_agent'
 require 'fileutils'
 
 class DebugAgentInputTest < Test::Unit::TestCase
@@ -11,7 +13,7 @@ class DebugAgentInputTest < Test::Unit::TestCase
   TMP_DIR = File.expand_path(File.dirname(__FILE__) + "/../tmp/in_debug_agent")
 
   def create_driver(conf = '')
-    Fluent::Test::InputTestDriver.new(Fluent::DebugAgentInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::DebugAgentInput).configure(conf)
   end
 
   def test_unix_path_writable
@@ -23,4 +25,25 @@ class DebugAgentInputTest < Test::Unit::TestCase
       create_driver %[unix_path #{TMP_DIR}/does_not_exist/test_path]
     end
   end
+
+  def test_multi_worker_environment_with_port
+    Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
+      d = Fluent::Test::Driver::Input.new(Fluent::Plugin::DebugAgentInput)
+      d.instance.instance_eval { @_fluentd_worker_id = 2 }
+      d.configure('port 24230')
+
+      assert_true d.instance.multi_workers_ready?
+      assert_equal(24232, d.instance.instance_variable_get(:@port))
+    end
+  end
+
+  def test_multi_worker_environment_with_unix_path
+    Fluent::SystemConfig.overwrite_system_config('workers' => 4) do
+      d = Fluent::Test::Driver::Input.new(Fluent::Plugin::DebugAgentInput)
+      d.instance.instance_eval { @_fluentd_worker_id = 2 }
+      d.configure("unix_path #{TMP_DIR}/test_path")
+
+      assert_false d.instance.multi_workers_ready?
+    end
+  end
 end

data/test/plugin/test_in_dummy.rb

@@ -1,5 +1,7 @@
 require_relative '../helper'
-require 'fluent/test'
+require 'fluent/test/driver/input'
+require 'fluent/plugin/in_dummy'
+require 'fileutils'
 
 class DummyTest < Test::Unit::TestCase
   def setup
@@ -7,13 +9,13 @@ class DummyTest < Test::Unit::TestCase
   end
 
   def create_driver(conf)
-    Fluent::Test::InputTestDriver.new(Fluent::DummyInput).configure(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::DummyInput).configure(conf)
   end
 
   sub_test_case 'configure' do
     test 'required parameters' do
       assert_raise_message("'tag' parameter is required") do
-        create_driver('')
+        Fluent::Plugin::DummyInput.new.configure(config_element('ROOT',''))
       end
     end
 
@@ -42,10 +44,6 @@ class DummyTest < Test::Unit::TestCase
       assert_equal 10, d.instance.rate
     end
 
-    def json_error_messages_regexp
-      /JSON::ParserError|got incomplete JSON|0th element of dummy, foo, is not a hash/
-    end
-
     test 'dummy' do
       # hash is okay
       d = create_driver(config + %[dummy {"foo":"bar"}])
@@ -55,7 +53,7 @@ class DummyTest < Test::Unit::TestCase
       d = create_driver(config + %[dummy [{"foo":"bar"}]])
       assert_equal [{"foo"=>"bar"}], d.instance.dummy
 
-      assert_raise_message(json_error_messages_regexp) do
+      assert_raise_message(/JSON::ParserError|got incomplete JSON/) do
         create_driver(config + %[dummy "foo"])
       end
 
@@ -74,26 +72,121 @@ class DummyTest < Test::Unit::TestCase
 
     test 'simple' do
       d = create_driver(config)
-      d.run {
-        # d.run sleeps 0.5 sec
-      }
-      emits = d.emits
-      emits.each do |tag, time, record|
+      d.run(timeout: 0.5)
+
+      d.events.each do |tag, time, record|
         assert_equal("dummy", tag)
         assert_equal({"foo"=>"bar"}, record)
+        assert(time.is_a?(Fluent::EventTime))
       end
     end
 
     test 'with auto_increment_key' do
       d = create_driver(config + %[auto_increment_key id])
-      d.run {
-        # d.run sleeps 0.5 sec
-      }
-      emits = d.emits
-      emits.each_with_index do |(tag, time, record), i|
+      d.run(timeout: 0.5)
+
+      d.events.each_with_index do |(tag, _time, record), i|
         assert_equal("dummy", tag)
         assert_equal({"foo"=>"bar", "id"=>i}, record)
       end
     end
   end
+
+  TEST_PLUGIN_STORAGE_PATH = File.join( File.dirname(File.dirname(__FILE__)), 'tmp', 'in_dummy', 'store' )
+  FileUtils.mkdir_p TEST_PLUGIN_STORAGE_PATH
+
+  sub_test_case "doesn't suspend internal counters in default" do
+    config1 = {
+      'tag' => 'dummy',
+      'rate' => '2',
+      'dummy' => '[{"x": 1, "y": "1"}, {"x": 2, "y": "2"}, {"x": 3, "y": "3"}]',
+      'auto_increment_key' => 'id',
+      'suspend' => false,
+    }
+    conf1 = config_element('ROOT', '', config1, [])
+    test "value of auto increment key is not suspended after stop-and-start" do
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
+
+      d1 = create_driver(conf1)
+      d1.run(timeout: 0.5) do
+        d1.instance.emit(4)
+      end
+
+      events = d1.events.sort{|a,b| a[2]['id'] <=> b[2]['id'] }
+
+      first_id1 = events.first[2]['id']
+      assert_equal 0, first_id1
+
+      last_id1 = events.last[2]['id']
+      assert { last_id1 > 0 }
+
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
+
+      d2 = create_driver(conf1)
+      d2.run(timeout: 0.5) do
+        d2.instance.emit(4)
+      end
+
+      events = d2.events.sort{|a,b| a[2]['id'] <=> b[2]['id'] }
+
+      first_id2 = events.first[2]['id']
+      assert_equal 0, first_id2
+
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-01.json'))
+    end
+  end
+
+  sub_test_case "suspend internal counters if suspend is true" do
+    setup do
+      FileUtils.rm_rf(TEST_PLUGIN_STORAGE_PATH)
+      FileUtils.mkdir_p(File.join(TEST_PLUGIN_STORAGE_PATH, 'json'))
+      FileUtils.chmod_R(0755, File.join(TEST_PLUGIN_STORAGE_PATH, 'json'))
+    end
+
+    config2 = {
+      '@id' => 'test-02',
+      'tag' => 'dummy',
+      'rate' => '2',
+      'dummy' => '[{"x": 1, "y": "1"}, {"x": 2, "y": "2"}, {"x": 3, "y": "3"}]',
+      'auto_increment_key' => 'id',
+      'suspend' => true,
+    }
+    conf2 = config_element('ROOT', '', config2, [
+              config_element(
+                'storage', '',
+                {'@type' => 'local',
+                 '@id' => 'test-02',
+                 'path' => File.join(TEST_PLUGIN_STORAGE_PATH,
+                                     'json', 'test-02.json'),
+                 'persistent' => true,
+                })
+            ])
+    test "value of auto increment key is suspended after stop-and-start" do
+      assert !File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
+
+      d1 = create_driver(conf2)
+      d1.run(timeout: 0.5) do
+        d1.instance.emit(4)
+      end
+
+      first_id1 = d1.events.first[2]['id']
+      assert_equal 0, first_id1
+
+      last_id1 = d1.events.last[2]['id']
+      assert { last_id1 > 0 }
+
+      assert File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
+
+      d2 = create_driver(conf2)
+      d2.run(timeout: 0.5) do
+        d2.instance.emit(4)
+      end
+      d2.events
+
+      first_id2 = d2.events.first[2]['id']
+      assert_equal last_id1 + 1, first_id2
+
+      assert File.exist?(File.join(TEST_PLUGIN_STORAGE_PATH, 'json', 'test-02.json'))
+    end
+  end
 end

data/test/plugin/test_in_exec.rb

@@ -1,156 +1,243 @@
 require_relative '../helper'
-require 'fluent/test'
-require 'net/http'
+require 'fluent/test/driver/input'
+require 'fluent/plugin/in_exec'
+require 'timecop'
 
 class ExecInputTest < Test::Unit::TestCase
+  SCRIPT_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..', 'scripts', 'exec_script.rb'))
+  TEST_TIME = "2011-01-02 13:14:15"
+  TEST_UNIX_TIME = Time.parse(TEST_TIME)
+
   def setup
     Fluent::Test.setup
-    @test_time = Time.parse("2011-01-02 13:14:15").to_i
-    @script = File.expand_path(File.join(File.dirname(__FILE__), '..', 'scripts', 'exec_script.rb'))
-  end
+    @test_time = event_time()
+  end
+
+  def create_driver(conf)
+    Fluent::Test::Driver::Input.new(Fluent::Plugin::ExecInput).configure(conf)
+  end
+
+  DEFAULT_CONFIG_ONLY_WITH_KEYS = %[
+    command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
+    run_interval 1s
+    tag "my.test.data"
+    <parse>
+      keys ["k1", "k2", "k3"]
+    </parse>
+  ]
+
+  TSV_CONFIG = %[
+    command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
+    run_interval 1s
+    <parse>
+      @type tsv
+      keys time, tag, k1
+    </parse>
+    <extract>
+      tag_key tag
+      time_key time
+      time_type string
+      time_format %Y-%m-%d %H:%M:%S
+    </extract>
+  ]
+
+  JSON_CONFIG = %[
+    command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 1
+    run_interval 1s
+    <parse>
+      @type json
+    </parse>
+    <extract>
+      tag_key tag
+      time_key time
+      time_type unixtime
+    </extract>
+  ]
+
+  MSGPACK_CONFIG = %[
+    command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 2
+    run_interval 1s
+    <parse>
+      @type msgpack
+    </parse>
+    <extract>
+      tag_key tagger
+      time_key datetime
+      time_type unixtime
+    </extract>
+  ]
+
+  # here document for not de-quoting backslashes
+  REGEXP_CONFIG = %[
+    command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 3
+    run_interval 1s
+    tag regex_tag
+] + <<'EOC'
+    <parse>
+      @type regexp
+      expression "(?<time>[^\\]]*) (?<message>[^ ]*)"
+      time_key time
+      time_type string
+      time_format %Y-%m-%d %H:%M:%S
+    </parse>
+EOC
+
+  sub_test_case 'with configuration with sections' do
+    test 'configure with default tsv format without extract' do
+      d = create_driver DEFAULT_CONFIG_ONLY_WITH_KEYS
+      assert{ d.instance.parser.is_a? Fluent::Plugin::TSVParser }
+      assert_equal "my.test.data", d.instance.tag
+      assert_equal ["k1", "k2", "k3"], d.instance.parser.keys
+    end
+
+    test 'configure raises error if both of tag and extract.tag_key are missing' do
+      assert_raise Fluent::ConfigError.new("'tag' or 'tag_key' option is required on exec input") do
+        create_driver %[
+          command ruby -e 'puts "yay"'
+          <parse>
+            keys y1
+          </parse>
+        ]
+      end
+    end
+
+    test 'configure for tsv' do
+      d = create_driver TSV_CONFIG
+      assert{ d.instance.parser.is_a? Fluent::Plugin::TSVParser }
+      assert_equal ["time", "tag", "k1"], d.instance.parser.keys
+      assert_equal "tag", d.instance.extract_config.tag_key
+      assert_equal "time", d.instance.extract_config.time_key
+      assert_equal :string, d.instance.extract_config.time_type
+      assert_equal "%Y-%m-%d %H:%M:%S", d.instance.extract_config.time_format
+    end
+
+    test 'configure for json' do
+      d = create_driver JSON_CONFIG
+      assert{ d.instance.parser.is_a? Fluent::Plugin::JSONParser }
+      assert_equal "tag", d.instance.extract_config.tag_key
+      assert_equal "time", d.instance.extract_config.time_key
+      assert_equal :unixtime, d.instance.extract_config.time_type
+    end
+
+    test 'configure for msgpack' do
+      d = create_driver MSGPACK_CONFIG
+      assert{ d.instance.parser.is_a? Fluent::Plugin::MessagePackParser }
+      assert_equal "tagger", d.instance.extract_config.tag_key
+      assert_equal "datetime", d.instance.extract_config.time_key
+      assert_equal :unixtime, d.instance.extract_config.time_type
+    end
 
-  def create_driver(conf = tsv_config)
-    Fluent::Test::InputTestDriver.new(Fluent::ExecInput).configure(conf)
+    test 'configure for regexp' do
+      d = create_driver REGEXP_CONFIG
+      assert{ d.instance.parser.is_a? Fluent::Plugin::RegexpParser }
+      assert_equal "regex_tag", d.instance.tag
+      expression = /(?<time>[^\]]*) (?<message>[^ ]*)/
+      assert_equal expression, d.instance.parser.expression
+      assert_nil d.instance.extract_config
+    end
   end
 
-  def tsv_config
-    %[
-      command ruby #{@script} "2011-01-02 13:14:15" 0
+  TSV_CONFIG_COMPAT = %[
+      command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 0
       keys time,tag,k1
       time_key time
       tag_key tag
       time_format %Y-%m-%d %H:%M:%S
       run_interval 1s
-    ]
-  end
+  ]
 
-  def json_config
-    %[
-      command ruby #{@script} #{@test_time} 1
+  JSON_CONFIG_COMPAT = %[
+      command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 1
       format json
       tag_key tag
       time_key time
       run_interval 1s
-    ]
-  end
+  ]
 
-  def msgpack_config
-    %[
-      command ruby #{@script} #{@test_time} 2
+  MSGPACK_CONFIG_COMPAT = %[
+      command ruby #{SCRIPT_PATH} #{TEST_UNIX_TIME.to_i} 2
       format msgpack
       tag_key tagger
       time_key datetime
       run_interval 1s
-    ]
-  end
+  ]
 
-  def regexp_config
-    %[
-      command ruby #{@script} "2011-01-02 13:14:15" 3
+  REGEXP_CONFIG_COMPAT = %[
+      command ruby #{SCRIPT_PATH} "#{TEST_TIME}" 3
       format /(?<time>[^\\\]]*) (?<message>[^ ]*)/
       tag regex_tag
       run_interval 1s
-    ]
-  end
-
-  def invalid_json_config
-    # For counting command execution, redirect stderr to file
-    %[
-      command ruby #{@script} #{@test_time} 4
-      format json
-      tag_key tag
-      time_key time
-      run_interval 0.5
-    ]
-  end
-
-  def test_configure
-    d = create_driver
-    assert_equal 'tsv', d.instance.format
-    assert_equal ["time","tag","k1"], d.instance.keys
-    assert_equal "tag", d.instance.tag_key
-    assert_equal "time", d.instance.time_key
-    assert_equal "%Y-%m-%d %H:%M:%S", d.instance.time_format
-  end
-
-  def test_configure_with_json
-    d = create_driver json_config
-    assert_equal 'json', d.instance.format
-    assert_equal [], d.instance.keys
-  end
-
-  def test_configure_with_msgpack
-    d = create_driver msgpack_config
-    assert_equal 'msgpack', d.instance.format
-    assert_equal [], d.instance.keys
-  end
-
-  def test_configure_with_regexp
-    d = create_driver regexp_config
-    assert_equal '/(?<time>[^\]]*) (?<message>[^ ]*)/', d.instance.format
-    assert_equal 'regex_tag', d.instance.tag
-  end
-
-  # TODO: Merge following tests into one case with parameters
-
-  def test_emit
-    d = create_driver
-
-    d.run do
-      sleep 2
+  ]
+
+  sub_test_case 'with traditional configuration' do
+    test 'configure' do
+      d = create_driver TSV_CONFIG_COMPAT
+      assert{ d.instance.parser.is_a? Fluent::Plugin::TSVParser }
+      assert_equal ["time","tag","k1"], d.instance.parser.keys
+      assert_equal "tag", d.instance.extract_config.tag_key
+      assert_equal "time", d.instance.extract_config.time_key
+      assert_equal "%Y-%m-%d %H:%M:%S", d.instance.extract_config.time_format
     end
 
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["tag1", @test_time, {"k1"=>"ok"}], emits[0]
-  end
-
-  def test_emit_json
-    d = create_driver json_config
-
-    d.run do
-      sleep 2
+    test 'configure_with_json' do
+      d = create_driver JSON_CONFIG_COMPAT
+      assert{ d.instance.parser.is_a? Fluent::Plugin::JSONParser }
     end
 
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["tag1", @test_time, {"k1"=>"ok"}], emits[0]
-  end
-
-  def test_emit_msgpack
-    d = create_driver msgpack_config
-
-    d.run do
-      sleep 2
+    test 'configure_with_msgpack' do
+      d = create_driver MSGPACK_CONFIG_COMPAT
+      assert{ d.instance.parser.is_a? Fluent::Plugin::MessagePackParser }
     end
 
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["tag1", @test_time, {"k1"=>"ok"}], emits[0]
+    test 'configure_with_regexp' do
+      d = create_driver REGEXP_CONFIG_COMPAT
+      assert{ d.instance.parser.is_a? Fluent::Plugin::RegexpParser }
+      assert_equal(/(?<time>[^\]]*) (?<message>[^ ]*)/, d.instance.parser.expression)
+      assert_equal('regex_tag', d.instance.tag)
+    end
   end
 
-  def test_emit_regexp
-    d = create_driver regexp_config
-
-    d.run do
-      sleep 2
+  sub_test_case 'with default configuration' do
+    setup do
+      @current_event_time = event_time('2016-10-31 20:01:30.123 -0700')
+      Timecop.freeze(Time.at(@current_event_time))
     end
 
-    emits = d.emits
-    assert_equal true, emits.length > 0
-    assert_equal ["regex_tag", @test_time, {"message"=>"hello"}], emits[0]
-    assert_equal @test_time, emits[0][1]
-  end
+    teardown do
+      Timecop.return
+    end
 
-  def test_emit_with_invalid_script
-    d = create_driver invalid_json_config
+    test 'emits events with current timestamp if time key is not specified' do
+      d = create_driver DEFAULT_CONFIG_ONLY_WITH_KEYS
+      d.run(expect_records: 2, timeout: 10)
 
-    d.run do
-      sleep 2
+      assert{ d.events.length > 0 }
+      d.events.each do |event|
+        assert_equal ["my.test.data", @current_event_time, {"k1"=>"2011-01-02 13:14:15", "k2"=>"tag1", "k3"=>"ok"}], event
+      end
     end
+  end
 
-    assert_equal true, d.emits.empty?
-    logs = d.instance.log.logs
-    assert_equal true, logs.count { |line| line =~ /exec failed to run or shutdown child process/ }.between?(1, 4)
+  data(
+    'default' => [TSV_CONFIG,     "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
+    'json'    => [JSON_CONFIG,    "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
+    'msgpack' => [MSGPACK_CONFIG, "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
+    'regexp'  => [REGEXP_CONFIG,  "regex_tag", event_time("2011-01-02 13:14:15"), {"message"=>"hello"}],
+    'default_c' => [TSV_CONFIG_COMPAT,     "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
+    'json_c'    => [JSON_CONFIG_COMPAT,    "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
+    'msgpack_c' => [MSGPACK_CONFIG_COMPAT, "tag1", event_time("2011-01-02 13:14:15"), {"k1"=>"ok"}],
+    'regexp_c'  => [REGEXP_CONFIG_COMPAT,  "regex_tag", event_time("2011-01-02 13:14:15"), {"message"=>"hello"}],
+  )
+  test 'emit with formats' do |data|
+    config, tag, time, record = data
+    d = create_driver(config)
+
+    d.run(expect_emits: 2, timeout: 10)
+
+    assert{ d.events.length > 0 }
+    d.events.each_with_index {|event, i|
+      assert_equal_event_time(time, event[1])
+      assert_equal [tag, time, record], event
+    }
   end
 end