logstash-output-monasca_log_api 0.3.3 → 0.4

data/spec/outputs/keystone/token_spec.rb

@@ -1,16 +1,16 @@
-=begin
-Copyright 2015 FUJITSU LIMITED
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
-in compliance with the License. You may obtain a copy of the License at
-
-http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software distributed under the License
-is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
-or implied. See the License for the specific language governing permissions and limitations under
-the License.
-=end
+# Copyright 2016 FUJITSU LIMITED
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
 
 # encoding: utf-8
 
@@ -18,21 +18,26 @@ require_relative '../spec_helper'
 
 describe LogStash::Outputs::Keystone::Token do
 
-  describe "#new" do
-    it "takes two parameters and returns a Token object" do
-      token = LogStash::Outputs::Keystone::Token.new('token-id', DateTime.now)
-      expect(token).to be_a(LogStash::Outputs::Keystone::Token)
-    end    
-  end
+  describe "when initializing" do
+    it "should be a singleton" do
+      expect{LogStash::Outputs::Keystone::Token.new}
+        .to raise_exception(NoMethodError)
+    end
 
-  describe "#==" do
-    it "should equal to another token instance" do
-      token = LogStash::Outputs::Keystone::Token.new('token-id', DateTime.parse("2015-05-26T08:55:36.774122Z"))
-      second_token = LogStash::Outputs::Keystone::Token.new('token-id', DateTime.parse("2015-05-26T08:55:36.774122Z"))
-      third_token = LogStash::Outputs::Keystone::Token.new('token-id', DateTime.parse("2015-05-30T08:55:36.774122Z"))
+    it "should always return the same object" do
+      token = LogStash::Outputs::Keystone::Token.instance
+      another_token = token = LogStash::Outputs::Keystone::Token.instance
+      expect(token).to eq(another_token)
+    end
+  end
 
-      expect(token).to eq(second_token)
-      expect(third_token).to_not eq(second_token)
+  describe "when changing properties" do
+    it "should change for each instance" do
+      token = LogStash::Outputs::Keystone::Token.instance
+      another_token = token = LogStash::Outputs::Keystone::Token.instance
+      another_token.set_token(1, 2)
+      expect(token).to eq(another_token)
     end
   end
+
 end

data/spec/outputs/monasca/monasca_log_api_client_spec.rb

@@ -0,0 +1,80 @@
+# Copyright 2016 FUJITSU LIMITED
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+# encoding: utf-8
+
+require_relative '../spec_helper'
+
+describe LogStash::Outputs::Monasca::MonascaLogApiClient do
+
+  let (:version) { '3.0' }
+  let (:valid_date) { DateTime.now + Rational(1, 1440) }
+  let (:token) { LogStash::Outputs::Keystone::Token
+    .instance.set_token('abc', valid_date) }
+  let (:logs) {  }
+  let (:header) { header = { 'X-Auth-Token' => token,
+    'Content-Type' => 'application/json' } }
+
+  before(:each) do
+    stub_const(
+      "LogStash::Outputs::Monasca::MonascaLogApiClient::SUPPORTED_API_VERSION",
+      [version])
+  end
+
+  context 'when initializing' do
+    it 'then it should register without exceptions' do
+      expect {LogStash::Outputs::Monasca::MonascaLogApiClient
+        .new('hostname:8080', 'v3.0')}.to_not raise_error
+    end
+  end
+
+  context 'when requesting to monasca-log-api' do
+    it 'sends x-auth-token and content-type in header, logs in body' do
+      client = LogStash::Outputs::Monasca::MonascaLogApiClient
+        .new('hostname:8080', 'v3.0')
+      expect_any_instance_of(RestClient::Resource).to receive(:post)
+        .with(logs.to_json, header)
+      client.send_logs(logs, token)
+    end
+  end
+
+  context 'when request failed' do
+    it 'rescued the exception and logs a failure' do
+      client = LogStash::Outputs::Monasca::MonascaLogApiClient
+        .new('hostname:8080', 'v3.0')
+      expect_any_instance_of(Cabin::Channel).to receive(:warn)
+      expect_any_instance_of(RestClient::Resource).to receive(:post)
+        .and_raise(Errno::ECONNREFUSED)
+      client.send_logs(logs, token)
+    end
+  end
+
+  context 'api version checking' do
+    it 'should pass for correct version' do
+      expect {LogStash::Outputs::Monasca::MonascaLogApiClient
+        .new('hostname:8080', 'v3.0')}.to_not raise_error
+    end
+
+    it 'should pass if version does not specify v' do
+      expect {LogStash::Outputs::Monasca::MonascaLogApiClient
+        .new('hostname:8080', '3.0')}.to_not raise_error
+    end
+
+    it 'should fail for unsupported version' do
+      expect {LogStash::Outputs::Monasca::MonascaLogApiClient
+        .new('hostname:8080', 'v4.0')}.to raise_exception
+    end
+  end
+
+end

data/spec/outputs/monasca_log_api_spec.rb

@@ -0,0 +1,433 @@
+# Copyright 2016 FUJITSU LIMITED
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+# encoding: utf-8
+
+require_relative 'spec_helper'
+
+describe 'outputs/monasca_log_api' do
+
+  let (:event) { LogStash::Event.new(
+    {
+      'message' => '2015-08-13 08:36:59,316 INFO monasca_notification '\
+      'graceful shutdown.',
+      '@version' => '1',
+      '@timestamp' => '2015-08-13T08:37:00.287Z',
+      'path' => '/opt/logstash-2.2.0/test.log',
+      'host' => 'kamil-choroba',
+      'type' => 'test-type',
+      'tags' => ['test-service', 'high']
+    })
+  }
+
+  let (:long_event) { LogStash::Event.new(
+    {
+      'message' => 'A veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'\
+      'eeery loooooooooooooooooooooooooooooooooooooooooong messsssssssssssssss'\
+      'sssssssssssssssssage ...... A veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'\
+      'eeeeeeeeeeeeeeeeeery loooooooooooooooooooooooooooooooooooooooooong mess'\
+      'ssssssssssssssssssssssssssssssssage ...... A veeeeeeeeeeeeeeeeeeeeeeeee'\
+      'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeery loooooooooooooooooooooooooooooooooo'\
+      'oooooooong messssssssssssssssssssssssssssssssssage ..... A veeeeeeeeeee'\
+      'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeery loooooooooooooooooooo'\
+      'oooooooooooooooooooooong messssssssssssssssssssssssssssssssssage ..... '\
+      'A veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeery loooooo'\
+      'oooooooooooooooooooooooooooooooooooong messssssssssssssssssssssssssssss'\
+      'ssssage ..... A veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'\
+      'eeeery loooooooooooooooooooooooooooooooooooooooooong messssssssssssssss'\
+      'ssssssssssssssssssage ..... A veeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'\
+      'eeeeeeeeeeeeeeeeeery loooooooooooooooooooooooooooooooooooooooooong mess'\
+      'ssssssssssssssssssssssssssssssssage ..... A veeeeeeeeeeeeeeeeeeeeeeeeee'\
+      'eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeery looooooooooooooooooooooooooooooooooo'\
+      'ooooooong messssssssssssssssssssssssssssssssssage .....  2015-08-13 08:'\
+      '36:59,316 INFO monasca_notification.main Received signal 17, beginning '\
+      'graceful shutdown.',
+      '@version' => '1',
+      '@timestamp' => '2015-08-13T08:37:00.287Z',
+      'path' => '/opt/logstash-2.2.0/test.log',
+      'host' => 'kamil-choroba',
+      'type' => 'test-type',
+      'dimensions' => '["[\"service\", \"nova\"]", "[\"priority\", \"high\"]"]',
+      'tags' => ['test-service', 'high']
+    })
+  }
+
+  let (:event_without_dims) { LogStash::Event.new(
+    {
+      'message' => 'A graceful shutdown.',
+      '@version' => '1',
+      '@timestamp' => '2015-08-13T08:37:00.287Z',
+      'path' => '/opt/logstash-2.2.0/test.log',
+      'host' => 'kamil-choroba',
+      'type' => 'test-type',
+      'tags' => ['test-service', 'high']
+    })
+  }
+
+  let (:event_with_one_dim) { LogStash::Event.new(
+    {
+      'message' => 'A graceful shutdown.',
+      '@version' => '1',
+      '@timestamp' => '2015-08-13T08:37:00.287Z',
+      'path' => '/opt/logstash-2.2.0/test.log',
+      'host' => 'kamil-choroba',
+      'type' => 'test-type',
+      'dimensions' => '["service", "nova"]',
+      'tags' => ['test-service', 'high']
+    })
+  }
+
+  let (:event_with_more_dims) { LogStash::Event.new(
+    {
+      'message' => 'A graceful shutdown.',
+      '@version' => '1',
+      '@timestamp' => '2015-08-13T08:37:00.287Z',
+      'path' => '/opt/logstash-2.2.0/test.log',
+      'host' => 'kamil-choroba',
+      'type' => 'test-type',
+      'dimensions' => '["[\"service\", \"nova\"]", "[\"priority\", \"high\"]"]',
+      'tags' => ['test-service', 'high']
+    })
+  }
+
+  let (:project_name) { 'monasca' }
+  let (:username) { 'operator' }
+  let (:password) { 'qweqwe' }
+
+  let (:complete_config) {
+    {
+      'monasca_log_api' => 'http://192.168.10.4:8080',
+      'monasca_log_api_version' => 'v3.0',
+      'keystone_api' => 'http://192.168.10.5:5000',
+      'project_name' => project_name,
+      'username' => username,
+      'password' => password,
+      'domain_id' => 'abadcf984cf7401e88579d393317b0d9',
+      'dimensions' => ['service:test'],
+      'num_of_logs' => 3,
+      'elapsed_time_sec' => 5000,
+      'delay' => 1,
+      'max_data_size_kb' => 4
+    }
+  }
+
+  let (:complete_config_short_elapsed_time) {
+    {
+      'monasca_log_api' => 'http://192.168.10.4:8080',
+      'monasca_log_api_version' => 'v3.0',
+      'keystone_api' => 'http://192.168.10.5:5000',
+      'project_name' => project_name,
+      'username' => username,
+      'password' => password,
+      'domain_id' => 'abadcf984cf7401e88579d393317b0d9',
+      'dimensions' => ['service:test'],
+      'num_of_logs' => 3,
+      'elapsed_time_sec' => 1,
+      'delay' => 1,
+      'max_data_size_kb' => 4
+    }
+  }
+
+  let (:simple_config) {
+    {
+      'monasca_log_api' => 'http://192.168.10.4:8080',
+      'keystone_api' => 'http://192.168.10.5:5000',
+      'project_name' => project_name,
+      'username' => username,
+      'password' => password,
+      'domain_id' => 'abadcf984cf7401e88579d393317b0d9',
+    }
+  }
+
+  let (:empty_config) { {} }
+
+  let (:valid_date) { DateTime.now + Rational(5, 1440) }
+  let (:expired_date) { DateTime.now - Rational(5, 1440) }
+  let (:token_id) { "f8cdafb7dce94444ad781a53ddaff693" }
+  let (:old_token_id) { "553ae6ea7d074f00a12750e4aa1dad50" }
+
+  let (:valid_token) { {:token => token_id,
+    :expires_at => valid_date } }
+
+  let (:expired_token) { {:token => old_token_id,
+    :expires_at => expired_date } }
+
+  after(:each) do
+    token = LogStash::Outputs::Keystone::Token.instance
+    token.set_token nil, nil
+  end
+
+  context 'when initializing' do
+
+    it 'without configuration, then raise error' do
+      expect {LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(empty_config)}.to raise_error(LogStash::ConfigurationError)
+    end
+
+    it 'with minimal configuration, then use defaults' do
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(simple_config)
+
+      expect(monasca_log_api.monasca_log_api_version).to be_instance_of(String)
+      expect(monasca_log_api.monasca_log_api_version).not_to be_empty
+      expect(monasca_log_api.dimensions).to be_nil
+      expect(monasca_log_api.num_of_logs).to be_instance_of(Fixnum)
+      expect(monasca_log_api.elapsed_time_sec).to be_instance_of(Fixnum)
+      expect(monasca_log_api.delay).to be_instance_of(Fixnum)
+      expect(monasca_log_api.max_data_size_kb).to be_instance_of(Fixnum)
+    end
+
+    it 'with complete configuration, then override settings' do
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+
+      expect(monasca_log_api.monasca_log_api_version)
+        .to eq(complete_config['monasca_log_api_version'])
+      expect(monasca_log_api.dimensions).to eq(complete_config['dimensions'])
+      expect(monasca_log_api.num_of_logs).to eq(complete_config['num_of_logs'])
+      expect(monasca_log_api.elapsed_time_sec)
+        .to eq(complete_config['elapsed_time_sec'])
+      expect(monasca_log_api.delay).to eq(complete_config['delay'])
+      expect(monasca_log_api.max_data_size_kb)
+        .to eq(complete_config['max_data_size_kb'])
+    end
+  end
+
+  context 'when registering' do
+    it 'should initialize the token' do
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      allow(monasca_log_api).to receive(:start_time_check)
+      expect {monasca_log_api.register}.to_not raise_error
+      expect(LogStash::Outputs::Keystone::Token.instance.id).not_to be_nil
+    end
+
+    it 'should start time check thread' do
+      expect_any_instance_of(LogStash::Outputs::MonascaLogApi)
+        .to receive(:start_time_check)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      allow(monasca_log_api).to receive(:init_token)
+      expect {monasca_log_api.register}.to_not raise_error
+    end
+  end
+
+  context 'initialize log body' do
+    it 'with dimensions' do
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      monasca_log_api.register
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'])
+        .not_to be_nil
+      expect(monasca_log_api.instance_variable_get(:@logs)['dimensions'])
+        .not_to be_nil
+      expect(monasca_log_api.instance_variable_get(:@logs)['dimensions'])
+        .not_to be_empty
+    end
+
+    it 'without dimensions' do
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(simple_config)
+      monasca_log_api.register
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'])
+        .not_to be_nil
+      expect(monasca_log_api.instance_variable_get(:@logs)['dimensions'])
+        .to be_nil
+    end
+  end
+
+  context 'when receiving messages' do
+    it 'collect messages' do
+      expect_any_instance_of(LogStash::Outputs::Monasca::MonascaLogApiClient)
+        .to_not receive(:send_logs)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(0)
+      monasca_log_api.multi_receive([event])
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(1)
+      monasca_log_api.multi_receive([event])
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(2)
+    end
+
+    it 'collect messages up to certain amount and send logs' do
+      expect_any_instance_of(LogStash::Outputs::Monasca::MonascaLogApiClient)
+        .to receive(:send_logs)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([event])
+      monasca_log_api.multi_receive([event])
+      monasca_log_api.multi_receive([event])
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(0)
+    end
+
+    it 'collect messages up to certain bytesize and send logs' do
+
+      expect_any_instance_of(LogStash::Outputs::Monasca::MonascaLogApiClient)
+        .to receive(:send_logs)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([long_event, long_event])
+      monasca_log_api.multi_receive([long_event])
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(1)
+    end
+
+    it 'sends logs after a specific time' do
+
+      expect_any_instance_of(LogStash::Outputs::Monasca::MonascaLogApiClient)
+        .to receive(:send_logs)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config_short_elapsed_time)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([event])
+
+      sleep(3)
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(0)
+    end
+  end
+
+  context 'when parsing events' do
+    it 'without dimensions' do
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([event_without_dims])
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'])
+        .to eq([{"message"=>"A graceful shutdown.",
+          "dimensions"=>{"path"=>"/opt/logstash-2.2.0/test.log",
+            "type"=>"test-type"}}])
+    end
+
+    it 'with one dimensions' do
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([event_with_one_dim])
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'])
+        .to eq([{"message"=>"A graceful shutdown.",
+          "dimensions"=>{"path"=>"/opt/logstash-2.2.0/test.log",
+            "type"=>"test-type", "service"=>"nova"}}])
+    end
+
+    it 'with more dimensions' do
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([event_with_more_dims])
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'])
+        .to eq([{"message"=>"A graceful shutdown.",
+          "dimensions"=>{"path"=>"/opt/logstash-2.2.0/test.log",
+            "type"=>"test-type", "service"=>"nova", "priority"=>"high"}}])
+    end
+  end
+
+  context 'after sending logs' do
+    it 'clears collected logs' do
+      expect_any_instance_of(LogStash::Outputs::Monasca::MonascaLogApiClient)
+        .to receive(:send_logs)
+      monasca_log_api = LogStash::Plugin.lookup('output', 'monasca_log_api')
+        .new(complete_config)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).and_return(valid_token)
+      allow(monasca_log_api).to receive(:start_time_check)
+
+      monasca_log_api.register
+      monasca_log_api.multi_receive([event])
+      monasca_log_api.multi_receive([event])
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(2)
+      monasca_log_api.multi_receive([event])
+
+      expect(monasca_log_api.instance_variable_get(:@logs)['logs'].size)
+        .to eq(0)
+    end
+  end
+
+  context 'check token' do
+    it 'if expired, renew it' do
+      expect_any_instance_of(LogStash::Outputs::Monasca::MonascaLogApiClient)
+        .to receive(:send_logs)
+      expect_any_instance_of(LogStash::Outputs::Keystone::KeystoneClient)
+        .to receive(:authenticate).with(complete_config['domain_id'],
+          complete_config['username'],
+          complete_config['password'],
+          complete_config['project_name'])
+        .and_return(expired_token, valid_token)
+      monasca_log_api = LogStash::Outputs::MonascaLogApi.new(complete_config)
+      allow(monasca_log_api).to receive(:start_time_check)
+      monasca_log_api.register
+      expect(LogStash::Outputs::Keystone::Token.instance.id).to eq(old_token_id)
+      monasca_log_api.multi_receive([event, event, event])
+      expect(LogStash::Outputs::Keystone::Token.instance.id).to eq(token_id)
+    end
+  end
+
+  context 'when stopping plugin' do
+    it 'then it should kill time thread' do
+      expect_any_instance_of(Thread).to receive(:kill)
+      monasca_log_api = LogStash::Outputs::MonascaLogApi.new(simple_config)
+      allow(monasca_log_api).to receive(:init_token)
+      monasca_log_api.register
+      monasca_log_api.close
+    end
+  end
+
+end