flydata 0.3.16 → 0.3.17

data/lib/flydata/parser/mysql/mysql_alter_table.treetop

@@ -215,7 +215,9 @@ grammar MysqlAlterTable
     }
     / convert_sym sp to_sym sp charset sp charset_name_or_default opt_collate {
       def action
-        { action: :convert_charset }
+        { action: :convert_charset,
+          cs: charset_name_or_default.charset
+         }
       end
     }
     / ( create_table_options_space_separated ) 1..1 {
@@ -795,6 +797,8 @@ grammar MysqlAlterTable
     / key_opt { def option; key_opt_option; end }
     / comment_opt { def option; comment_opt_option; end }
     / column_format_opt { def option; column_format_opt_option; end }
+    / character_set_opt { def option; character_set_opt_option; end }
+    / collate_opt { def option; collate_opt_option; end }
     / storage_opt { def option; storage_opt_option; end }
     #TODO: / reference_definition
   end
@@ -889,6 +893,20 @@ grammar MysqlAlterTable
       end
     }
   end
+  rule character_set_opt
+    'character set'i sp value {
+      def character_set_opt_option
+        { cs: FlydataCore::TableDef::MysqlTableDef.flydata_charset(value.raw_value) }
+      end
+    }
+  end
+  rule collate_opt
+    'collate'i sp value {
+      def collate_opt_option
+        {} # Not supported
+      end
+    }
+  end
   rule storage_opt
     'storage'i sp ( 'disk'i / 'memory'i / 'default'i ) {
       def storage_opt_option
@@ -1012,8 +1030,8 @@ grammar MysqlAlterTable
   end
 
   rule charset_name_or_default
-    default_sym
-    / charset_name
+    default_sym { def charset; 'DEFAULT'; end }
+    / charset_name { def charset; FlydataCore::TableDef::MysqlTableDef.flydata_charset(text_value); end }
   end
 
   rule collation_name
@@ -1047,7 +1065,9 @@ grammar MysqlAlterTable
   rule create_table_option
     default_charset {
       def action
-        { action: :default_charset }
+        { action: :default_charset,
+          cs: charset
+        }
       end
     }
     / default_collation {
@@ -1073,7 +1093,11 @@ grammar MysqlAlterTable
   end
 
   rule default_charset
-    opt_default nsp charset opt_equal nsp charset_name_or_default
+    opt_default nsp charset opt_equal nsp charset_name_or_default {
+      def charset
+        charset_name_or_default.charset
+      end
+    }
   end
 
   rule opt_default

data/lib/flydata/sync_file_manager.rb

@@ -41,14 +41,27 @@ module Flydata
         state: items[5], substate: items[6], mysql_table: mysql_table}
     end
 
-    def mark_generated_tables(tables)
+    def load_generated_ddl(tables)
+      tables = [ tables ] unless tables.kind_of?(Array)
+      paths = table_ddl_file_paths(*tables)
+      paths.collect{|path|
+        begin
+          File.open(path) {|f| f.read }
+        rescue Errno::ENOENT
+          nil
+        end
+      }
+    end
+
+    def save_generated_ddl(tables, contents = "1")
+      tables = [ tables ] unless tables.kind_of?(Array)
       table_positions_dir_path = ENV['FLYDATA_TABLE_POSITIONS'] || File.join(FLYDATA_HOME, 'positions')
       #Create positions if dir does not exist
       unless File.directory?(table_positions_dir_path)
         FileUtils.mkdir_p(table_positions_dir_path)
       end
       tables.each do |tab|
-        File.open(File.join(table_positions_dir_path, "#{tab}.generated_ddl"), 'w') {|f| f.write("1") }
+        File.open(File.join(table_positions_dir_path, "#{tab}.generated_ddl"), 'w') {|f| f.write(contents) }
       end
     end
 

data/spec/flydata/command/sync_spec.rb

@@ -5,6 +5,9 @@ require 'flydata/command/sync'
 module Flydata
   module Command
     describe Sync do
+      let(:subject_object){ described_class.new }
+      subject { subject_object }
+
       let(:default_mysqldump_dir) do
         File.join('/tmp', "sync_dump_#{Time.now.to_i}")
       end
@@ -35,6 +38,14 @@ module Flydata
             "data_servers"=>"localhost:9905" }
          }
       end
+      let(:mysql_table_columns) {
+        {"id"=>{:column_name=>"id", :format_type_str=>"int(11)", :format_type=>"int", :format_size=>11}, "name"=>{:column_name=>"name", :format_type_str=>"varchar(40)", :format_type=>"varchar", :format_size=>40, :default=>nil}, "created_at"=>{:column_name=>"created_at", :format_type_str=>"timestamp", :format_type=>"timestamp", :default=>"CURRENT_TIMESTAMP"}, "bin"=>{:column_name=>"bin", :format_type_str=>"binary(34)", :format_type=>"binary", :format_size=>34, :default=>nil}, "bin2"=>{:column_name=>"bin2", :format_type_str=>"blob", :format_type=>"blob"}, "varbin"=>{:column_name=>"varbin", :format_type_str=>"varchar(34)", :format_type=>"varchar", :format_size=>34, :default=>nil}}
+      }
+      let(:mysql_table) do
+        mt = double('mysql_table')
+        allow(mt).to receive(:columns).and_return(mysql_table_columns)
+        mt
+      end
 
       after :each do
         if Dir.exists?(default_mysqldump_dir)
@@ -45,7 +56,6 @@ module Flydata
         end
       end
 
-      subject { Sync.new }
       describe '#cleanup_sync_server' do
         let(:rest_client) { double('rest_client') }
 
@@ -232,6 +242,17 @@ module Flydata
           include_examples 'throws an error'
         end
       end
+      describe '#convert_to_flydata_values' do
+        subject { subject_object.send(:convert_to_flydata_values, mysql_table, values) }
+        let(:values) { [4, 'John', nil, '0xC0448200', nil, nil] }
+
+        it 'calls convert_to_valydata_value for each value' do
+          mysql_table.columns.values.each_with_index do |col_info, i|
+            expect(FlydataCore::TableDef::MysqlTableDef).to receive(:convert_to_flydata_value).with(values[i], col_info[:format_type]).and_return(values[i])
+          end
+          is_expected.to eq values
+        end
+      end
     end
   end
 end

data/spec/flydata/fluent-plugins/in_mysql_binlog_flydata_spec.rb

@@ -167,7 +167,8 @@ EOT
         record = row.kind_of?(Hash) && row.keys.include?(:row) ? row : { row: row }
         @seq += 1
         record.merge({ :type=>type, :table_name=>table, :respect_order=>true,
-          :seq=>@seq, :src_pos=>"#{binlog_file}\t#{position}", :table_rev=>1 })
+          :seq=>@seq, :src_pos=>"#{binlog_file}\t#{position}", :table_rev=>1,
+          :v=>2 })
       end
       expect_emitted_records(event, records)
     end
@@ -193,6 +194,7 @@ EOT
     let(:rotate_event_corrupt){ create_event(TEST_EVENT_ROTATE_MISSING_BINLOG_FILE) }
 
     let(:now) { Time.now }
+    let(:flydata_record_version) { 2 }
 
     let(:binlog_position_file) do
       f = double('binlog_position_file')
@@ -226,7 +228,7 @@ EOT
       setup_initial_flydata_files
       allow(MysqlBinlogInput::BinlogUtil).to receive(:to_hash) {|e| e}
       allow(Mysql::BinLogPositionFile).to receive(:new).with(TEST_POSITION_FILE).and_return(binlog_position_file)
-      allow(Mysql::TableMeta).to receive(:update)
+      allow(Flydata::Mysql::TableMeta).to receive(:update)
       allow(plugin).to receive(:`).with("mysql -V").and_return("mysql  Ver 14.14 Distrib 5.5.40")
       allow(plugin).to receive(:`).with(/^echo 'select version\(\);'/).and_return("version()\n5.5.40-0ubuntu0.12.04.1-log")
       Timecop.freeze(now)
@@ -326,6 +328,7 @@ EOT
               src_pos: "mysql-bin.000048\t689",
               table_rev: 2,  # increment revision
               seq: 2,
+              v: flydata_record_version,
               actions: [{
                 action: :add_column, column: "sum", :type=>'int4(11)', :query=>'add column sum integer'}],
             })
@@ -341,6 +344,7 @@ EOT
               src_pos: "mysql-bin.000048\t800",
               table_rev: 2,  # increment revision
               seq: 2,
+              v: flydata_record_version,
               actions: [{
                 action: :drop_column, column: "sum", :query=>'drop column sum'}],
             })
@@ -357,6 +361,7 @@ EOT
               src_pos: "mysql-bin.000048\t#{337 - 217}",
               table_rev: 1,
               seq: 2,
+              v: flydata_record_version,
               actions: [{
                 action: :add_index,
                 support_level: :nonbreaking,

data/spec/flydata/fluent-plugins/mysql/dml_record_handler_spec.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+require 'fluent_plugins_spec_helper'
+require 'flydata/fluent-plugins/mysql/dml_record_handler'
+
+module Mysql
+
+describe DmlRecordHandler do
+  let(:subject_object) { described_class.new(context) }
+
+  let(:table_meta) { double('table_meta') }
+  let(:tables) { ['items', 'orders'] }
+  let(:sync_fm) {
+    sfm = double('sync_fm')
+    allow(sfm).to receive(:get_table_binlog_pos).and_return nil
+    sfm
+  }
+  let(:context) {
+    c = double('context')
+    allow(c).to receive(:table_meta).and_return(table_meta)
+    allow(c).to receive(:tables).and_return(tables)
+    allow(c).to receive(:sync_fm).and_return(sync_fm)
+    c
+  }
+
+  describe '#encode_row_value' do
+    subject { subject_object.send(:encode_row_value, value) }
+
+    let(:normal_utf8_string) { "ABC新年Ã" }
+    let(:valid_utf8_string) { "\x00abc" } # Yes, this is a valid UTF-8 string
+    let(:invalid_utf8_string) { "新年".encode('shift_jis') }
+    let(:latin1_string_happened_to_be_a_valid_utf8_string) { "ã".encode("iso-8859-1") }
+
+    shared_examples 'encoding values differently based on their contents not based on encoding' do
+      context 'with a normal utf-8 string' do
+        let(:value) { normal_utf8_string }
+        it 'returns a utf8 string' do
+          result = subject
+          expect(result).to eq normal_utf8_string
+          expect(result.encoding).to eq Encoding.find('utf-8')
+        end
+      end
+      context 'with a valid utf-8 string' do
+        let(:value) { valid_utf8_string }
+        it 'returns a utf8 string' do
+          result = subject
+          expect(result).to eq valid_utf8_string
+          expect(result.encoding).to eq Encoding.find('utf-8')
+        end
+      end
+      context 'with an invalid utf-8 string' do
+        let(:value) { invalid_utf8_string }
+        it 'returns a FlyData binary format string as BINARY encoding' do
+          result = subject
+          expect(result).to eq "0x9056944E"
+          expect(result.encoding).to eq Encoding::BINARY
+        end
+      end
+      context 'with a latin1 string which happens to be a valid utf8 character' do
+        let(:value) { latin1_string_happened_to_be_a_valid_utf8_string }
+        it 'returns a utf8 string' do
+          result = subject
+          expect(result).to eq latin1_string_happened_to_be_a_valid_utf8_string
+          expect(result).to eq "ã" # #C3A3
+          expect(result.encoding).to eq Encoding.find('utf-8')
+        end
+      end
+    end
+
+    context 'with strings whose encoding is utf-8' do
+      before do
+        normal_utf8_string.force_encoding 'utf-8'
+        valid_utf8_string.force_encoding 'utf-8'
+        invalid_utf8_string.force_encoding 'utf-8'
+        latin1_string_happened_to_be_a_valid_utf8_string.force_encoding 'utf-8'
+      end
+      it_behaves_like 'encoding values differently based on their contents not based on encoding'
+    end
+
+    context 'with strings whose encoding is binary' do
+      before do
+        normal_utf8_string.force_encoding 'binary'
+        valid_utf8_string.force_encoding 'binary'
+        invalid_utf8_string.force_encoding 'binary'
+        latin1_string_happened_to_be_a_valid_utf8_string.force_encoding 'binary'
+      end
+      it_behaves_like 'encoding values differently based on their contents not based on encoding'
+    end
+  end
+
+  describe '#convert_to_flydata_row_format' do
+    subject { subject_object.send(:convert_to_flydata_row_format, row) }
+
+    let(:row) { [ value ] }
+    before do
+    end
+
+    shared_examples "returning a json hash with no attrs" do
+      it do
+        is_expected.to eq({"1" => value })
+      end
+    end
+
+    context 'with a row containing a string value' do
+      let(:value) { "a normal string" }
+
+      before do
+        expect(subject_object).to receive(:encode_row_value).with(value).and_return(value)
+      end
+
+      it_behaves_like "returning a json hash with no attrs"
+    end
+    context 'with a row containing a binary value' do
+      let(:value) { "\x00abc".force_encoding('binary') }
+      before do
+        expect(subject_object).to receive(:encode_row_value).with(value).and_return(value)
+      end
+      it "returns a json hash with attrs" do
+        is_expected.to eq({"1" => value, "attrs" => {"1" => {"enc" => "b" }}})
+      end
+    end
+    context 'with a row containing an integer value' do
+      let(:value) { 4 }
+
+      it_behaves_like "returning a json hash with no attrs"
+    end
+  end
+end
+
+end

data/spec/flydata/fluent-plugins/mysql/shared_query_handler_context.rb

@@ -14,6 +14,7 @@ module Mysql
     let(:current_binlog_file) { "mysql-bin.000066" }
     let(:tag) { "some_tag" }
     let(:table_rev) { 1 }
+    let(:flydata_record_version) { 2 }
     let(:context) do
       r = double('context')
       allow(r).to receive(:sync_fm).and_return(sync_fm)

data/spec/flydata/fluent-plugins/mysql/table_meta_spec.rb

@@ -1,6 +1,7 @@
 require 'fluent_plugins_spec_helper'
 require 'flydata/fluent-plugins/mysql/table_meta'
 
+module Flydata
 module Mysql
   describe TableMeta do
     let(:db_opts) { { host: 'test-host', port: 3306, username: 'test-user', password: 'test-pswd', database: 'test-db' } }
@@ -9,6 +10,9 @@ module Mysql
 
     let(:conn) { double('conn') }
     let(:table_meta) { TableMeta.new(db_opts.merge(database: database, tables: tables)) }
+    let(:utf8) { 'utf8' }
+    let(:latin1) { 'latin1' }
+    let(:cp932) { 'cp932' }
 
     before do
       allow(conn).to receive(:close)
@@ -24,23 +28,26 @@ module Mysql
       context 'when character_set_name is supported' do
         context 'when encoding is not necessary' do
           let(:query_result) {[
-            {'table_name' => 'a_table', 'character_set_name' => 'utf8' }
+            {'table_name' => 'a_table', 'character_set_name' => utf8 }
           ]}
           it 'set nil for encoding' do
             table_meta.update
-            expect(table_meta['a_table'][:encoding]).to be_nil
+            expect(table_meta['a_table'][:encoding]).to eq Encoding::UTF_8
+            expect(table_meta['a_table'][:mysql_charset]).to eq utf8
           end
         end
 
         context 'when encoding is needed' do
           let(:query_result) {[
-            {'table_name' => 'a_table', 'character_set_name' => 'latin1' },
-            {'table_name' => 'b_table', 'character_set_name' => 'cp932' }
+            {'table_name' => 'a_table', 'character_set_name' => latin1 },
+            {'table_name' => 'b_table', 'character_set_name' => cp932 }
           ]}
           it 'set ruby encoding encoding' do
             table_meta.update
-            expect(table_meta['a_table'][:encoding]).to eq('ISO-8859-1')
-            expect(table_meta['b_table'][:encoding]).to eq('CP932')
+            expect(table_meta['a_table'][:encoding]).to eq Encoding::ISO_8859_1
+            expect(table_meta['a_table'][:mysql_charset]).to eq latin1
+            expect(table_meta['b_table'][:encoding]).to eq Encoding::CP932
+            expect(table_meta['b_table'][:mysql_charset]).to eq cp932
           end
         end
       end
@@ -56,5 +63,4 @@ module Mysql
     end
   end
 end
-
-
+end

data/spec/flydata/fluent-plugins/mysql/truncate_query_handler_spec.rb

@@ -16,7 +16,8 @@ module Mysql
           respect_order: true,
           src_pos: "#{current_binlog_file}\t#{next_position - event_length}",
           table_rev: table_rev,
-          seq: seq
+          seq: seq,
+          v: flydata_record_version
         }
       end
       before do

data/spec/flydata/{fluent-plugins/mysql → mysql}/binlog_position_spec.rb

@@ -1,6 +1,6 @@
 require 'fluent_plugins_spec_helper'
-require 'mysql/binlog_position'
-
+require 'flydata/mysql/binlog_position'
+module Flydata
 module Mysql
   describe BinLogPosition do
     let(:pos1) { BinLogPosition.new('mysql-bin.000064	107') }
@@ -32,3 +32,4 @@ module Mysql
     end
   end
 end
+end

data/spec/flydata/{util → mysql}/mysql_util_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
-require 'flydata/util/mysql_util'
+require 'flydata/mysql/mysql_util'
 
 module Flydata
-  module Util
+  module Mysql
 
     describe MysqlUtil do
       let(:default_option) { {

data/spec/flydata/mysql/table_ddl_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+require 'flydata/mysql/table_ddl'
+
+module Flydata
+module Mysql
+
+describe TableDdl do
+  let(:table_name1) { "items" }
+  let(:table_name2) { "orders" }
+  let(:table_names) { [table_name1, table_name2] }
+  let(:table1_charset) { 'utf8' }
+  let(:table2_charset) { 'sjis' }
+  let(:at_charset_event_table1) { double('at_charset_event_table1') }
+  let(:at_charset_event_table2) { double('at_charset_event_table2') }
+  let(:at_column_charset_event_table1) { double('at_column_charset_event_table1') }
+  let(:expected_alter_table_charset_events) { [ at_charset_event_table1, at_charset_event_table2] }
+  let(:at_charset_query) { "ALTER TABLE `#{database_name}`.`#{at_table}` CHARACTER SET = #{charset};" }
+  let(:query) { "ALTER TABLE `#{database_name}`.`#{event_table_name}` CHARACTER SET = #{charset};" }
+  let(:column_query1) { "ALTER TABLE `#{database_name}`.`#{event_table_name}` CHANGE COLUMN `#{table1_varchar_column}` #{table1_varchar_column_def};" }
+  let(:charset) { 'utf8' }
+  let(:event_type) { 'Query' }
+  let(:database_name) { "a_database" }
+  let(:sync_fm) { double('sync_fm') }
+  let(:master_binlog_position) { "#{binlog_file}\t#{binlog_position}" }
+  let(:binlog_file) { "mysql-binlog.00123" }
+  let(:binlog_position) { 28393 }
+  let(:original_current_binlog_file) { double('original_current_binlog_file') }
+  let(:mysql_opts) { { host: double('host'), port: double('port'),
+                       username: double('username'),
+                       password: double('password'),
+                       database: database_name,
+                   } }
+  let(:position_file) { double('position_file') }
+  let(:context) { double('context') }
+  let(:mysql_tabledef) { { table_name1 => mysql_tabledef1,
+                           table_name2 => mysql_tabledef2,
+                       } }
+  let(:mysql_tabledef1) { double('mysql_tabledef1') }
+  let(:mysql_tabledef2) { double('mysql_tabledef2') }
+  let(:column_def1) { { "id" => "`id` integer NOT NULL",
+                        table1_varchar_column => table1_varchar_column_def,
+                    } }
+  let(:table1_varchar_column) { 'name' }
+  let(:table1_varchar_column_def) { "`#{table1_varchar_column}` varchar(45)#{charset_option1} NULL" }
+  let(:column_def2) { { "id" => "`id` integer NOT NULL",
+                        "address" => "`address` varchar(45) NULL"
+                    } }
+  let(:charset_option1) { "" }
+  let(:save) { {} }
+
+  before do
+    save[:log] = $log
+    $log = double('$log')
+    allow($log).to receive(:info)
+    allow($log).to receive(:debug)
+    allow($log).to receive(:error)
+    allow($log).to receive(:trace)
+
+    allow(mysql_tabledef1).to receive(:default_charset_mysql).and_return(table1_charset)
+    allow(mysql_tabledef1).to receive(:table_name).and_return(table_name1)
+    allow(mysql_tabledef1).to receive(:column_def).and_return(column_def1)
+    allow(mysql_tabledef2).to receive(:default_charset_mysql).and_return(table2_charset)
+    allow(mysql_tabledef2).to receive(:table_name).and_return(table_name2)
+    allow(mysql_tabledef2).to receive(:column_def).and_return(column_def2)
+  end
+
+  after do
+    $log = save[:log]
+  end
+
+  describe '.migrate_to_v2' do
+    let(:subject_object) { described_class }
+    let(:subject_params) { [:migrate_to_v2, table_names, mysql_opts, sync_fm, position_file, context] }
+
+    let(:target_version) { "2" }
+
+    shared_examples "create and send charset records and increment version" do
+      let(:next_position) { binlog_position }
+
+      it do
+        matcher = receive(:each_mysql_tabledef).with(table_names, mysql_opts)
+        matcher = table_names.inject(matcher) {|m, tn| m.and_yield(mysql_tabledef[tn], nil) }
+        expect(MysqlUtil).to matcher
+        expect(File).to receive(:open).with(position_file).and_return(master_binlog_position)
+        expect(context).to receive(:current_binlog_file).and_return(original_current_binlog_file)
+        expect(context).to receive(:current_binlog_file=).with(binlog_file)
+        expect(context).to receive(:current_binlog_file=).with(original_current_binlog_file)
+        expect(sync_fm).to receive(:save_generated_ddl).with(table_names, target_version)
+
+        expect{|b| subject_object.send(*subject_params, &b) }.to yield_successive_args(*expected_alter_table_charset_events)
+      end
+    end
+    shared_examples "does nothing" do
+      it do
+        expect(sync_fm).not_to receive(:save_generated_ddl)
+
+        expect{|b| subject_object.send(*subject_params, &b) }.not_to yield_control
+      end
+    end
+
+    let(:table_versions) { table_names.size.times.collect{ current_version } }
+    before do
+      expect(sync_fm).to receive(:load_generated_ddl).with(table_names).and_return table_versions
+    end
+
+    context "with a single table" do
+      let(:table_names) { [table_name1] }
+      let(:event_table_name) { table_name1 }
+      let(:charset) { table1_charset }
+      let(:expected_alter_table_charset_events) { [ at_charset_event_table1 ] }
+
+      context "with a table whose version is 0" do
+        let(:current_version) { nil } # generate_ddl file doesn't exist in case of version "0"
+        before do
+          expect(QueryEvent).to receive(:new).with(event_type, database_name, event_table_name, next_position, 0, query, Integer).and_return(at_charset_event_table1)
+        end
+        it_behaves_like "create and send charset records and increment version"
+      end
+      context "with a table whose version is 1" do
+        let(:current_version) { "1" }
+        before do
+          expect(QueryEvent).to receive(:new).with(event_type, database_name, event_table_name, next_position, 0, query, Integer).and_return(at_charset_event_table1)
+        end
+        it_behaves_like "create and send charset records and increment version"
+      end
+      context "with a table whose version is 2" do
+        let(:current_version) { "2" }
+        it_behaves_like "does nothing"
+      end
+      context "with a table whose version is 3" do
+        let(:current_version) { "3" }
+        it_behaves_like "does nothing"
+      end
+      context 'with a single table who has a column with charset' do
+        let(:charset_option1) { " CHARACTER SET 'latin5'" }
+        let(:expected_alter_table_charset_events) { [ at_column_charset_event_table1, at_charset_event_table1 ] }
+
+        context "with a table whose version is 0" do
+          let(:current_version) { nil } # generate_ddl file doesn't exist in case of version "0"
+          before do
+            expect(QueryEvent).to receive(:new).with(event_type, database_name, event_table_name, next_position, 0, column_query1, Integer).and_return(at_column_charset_event_table1)
+            expect(QueryEvent).to receive(:new).with(event_type, database_name, event_table_name, next_position, 0, query, Integer).and_return(at_charset_event_table1)
+          end
+          it_behaves_like "create and send charset records and increment version"
+        end
+      end
+    end
+  end
+end
+
+describe QueryEvent do
+  let(:subject_object) { described_class.new(event_type, database_name, event_table_name, next_position, event_length, query, timestamp) }
+
+  let(:event_type) { 'Query' }
+  let(:database_name) { 'mydb' }
+  let(:event_table_name) { 'mytable' }
+  let(:next_position) { 38293 }
+  let(:event_length) { 2093 }
+  let(:query) { 'ALTER TABLE CHARACTER SET sjis' }
+  let(:timestamp) { Time.now.to_i }
+
+  describe "#event_type" do
+    subject { subject_object.event_type }
+    it { is_expected.to eq event_type }
+  end
+  describe "#database_name" do
+    subject { subject_object.database_name }
+    it { is_expected.to eq database_name}
+  end
+  describe "#event_table_name" do
+    subject { subject_object.event_table_name }
+    it { is_expected.to eq event_table_name}
+  end
+  describe "#next_position" do
+    subject { subject_object.next_position }
+    it { is_expected.to eq next_position}
+  end
+  describe "#event_length" do
+    subject { subject_object.event_length }
+    it { is_expected.to eq event_length}
+  end
+  describe "#query" do
+    subject { subject_object.query }
+    it { is_expected.to eq query}
+  end
+  describe "#timestamp" do
+    subject { subject_object.timestamp }
+    it { is_expected.to eq timestamp}
+  end
+end
+
+end
+end