fluentd-ui 1.0.0.beta.1 → 1.0.0

data/spec/models/fluentd/setting/out_tdlog_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Fluentd::Setting::OutTdlog do
-  let(:klass) { described_class }
-  let(:instance) { klass.new(valid_attributes) }
-  let(:valid_attributes) {
-    {
-      pattern: "td.*.*",
-      apikey: "APIKEY",
-      auto_create_table: "true",
-    }
-  }
-
-  describe "#valid?" do
-    it "should be invalid if apikey is missing" do
-      params = valid_attributes.dup
-      params.delete(:apikey)
-      instance = klass.new(params)
-      instance.should_not be_valid
-      instance.errors.full_messages.should == ["'apikey' parameter is required"]
-    end
-  end
-
-  describe "#plugin_name" do
-    subject { instance.plugin_name }
-    it { should == "tdlog" }
-  end
-
-  describe "#plugin_type" do
-    subject { instance.plugin_type }
-    it { should == "output" }
-  end
-
-  describe "#to_config" do
-    subject { instance.to_config.to_s }
-    let(:expected) {
-      <<-CONFIG
-<match td.*.*>
-  @type tdlog
-  apikey APIKEY
-</match>
-      CONFIG
-    }
-    it { should == expected }
-  end
-end

data/spec/models/fluentd_log_spec.rb

@@ -1,171 +0,0 @@
-# coding: utf-8
-require "spec_helper"
-
-describe FluentdLog do
-  describe "#read" do
-    let(:log) { FluentdLog.new(logfile) }
-    let(:logfile) { Rails.root.join("tmp", "dummylog").to_s }
-
-    before { File.open(logfile, "wb"){|f| f.write content } }
-    subject { log.read }
-
-    context "compatible with utf-8" do
-      let(:content) { "utf8あいう\n" }
-      it { subject.should == content }
-    end
-
-    context "incompatible with utf-8" do
-      let(:content) { "eucあいう\n".encode('euc-jp').force_encoding('ascii-8bit') }
-      it { subject.should == content }
-    end
-  end
-
-  describe "#tail" do
-    let(:log) { FluentdLog.new(logfile) }
-    let(:logfile) { Rails.root.join("tmp", "dummylog").to_s }
-
-    before { File.open(logfile, "wb"){|f| f.write content } }
-
-    context "5 lines log" do
-      let(:content) { 5.times.map{|n| "#{n}\n"}.join }
-
-      context "tail(5)" do
-        let(:limit) { 5 }
-        subject { log.tail(limit) }
-
-        it { should == %w(4 3 2 1 0) }
-      end
-
-      context "tail(3)" do
-        let(:limit) { 3 }
-        subject { log.tail(limit) }
-
-        it { should == %w(4 3 2) }
-      end
-
-      context "tail(99)" do
-        let(:limit) { 99 }
-        subject { log.tail(limit) }
-
-        it { should == %w(4 3 2 1 0) }
-      end
-    end
-  end
-
-  describe "#logged_errors" do
-    let(:log) { FluentdLog.new(logfile) }
-
-    describe "#last_error_message" do
-      subject { log.last_error_message }
-
-      context "have 0 error log" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error0.log", Rails.root) }
-
-        it { should be_empty }
-      end
-
-      context "have 2 error log" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error2.log", Rails.root) }
-
-        it { should == log.recent_errors(1).first[:subject] }
-      end
-    end
-
-    describe "#errors_since" do
-      let(:logged_time) { Time.parse('2014-05-27') }
-      let(:now) { Time.parse('2014-05-29') }
-
-      before { Timecop.freeze(now) }
-      after { Timecop.return }
-
-      subject { log.errors_since(days.days.ago) }
-
-      context "has no errors" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error0.log", Rails.root) }
-        let(:days) { 100 }
-
-        it "empty array" do
-          should be_empty
-        end
-      end
-
-      context "has errors" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error2.log", Rails.root) }
-
-        context "unreachable since" do
-          let(:days) { 0 }
-          it { should be_empty }
-        end
-
-        context "reachable since" do
-          let(:days) { 100 }
-
-          it "contain stack trace" do
-            subject[0][:subject].should include("Address already in use - bind(2)")
-          end
-
-          it "newer(bottom) is first" do
-            one = Time.parse(subject[0][:subject])
-            two = Time.parse(subject[1][:subject])
-            one.should >= two
-          end
-        end
-      end
-    end
-
-    describe "#recent_errors" do
-      context "have 0 error log" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error0.log", Rails.root) }
-        subject { log.recent_errors(2) }
-
-        it "empty array" do
-          should be_empty
-        end
-      end
-
-      context "have 2 error log" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error2.log", Rails.root) }
-        subject { log.recent_errors(2) }
-
-        describe "limit" do
-          subject { log.recent_errors(limit).length }
-
-          context "=1" do
-            let(:limit) { 1 }
-            it { should == limit }
-          end
-
-          context "=2" do
-            let(:limit) { 2 }
-            it { should == limit }
-          end
-        end
-
-        it "contain stack trace" do
-          subject[0][:subject].should include("Address already in use - bind(2)")
-        end
-
-        it "newer(bottom) is first" do
-          one = Time.parse(subject[0][:subject])
-          two = Time.parse(subject[1][:subject])
-          one.should >= two
-        end
-      end
-
-      context "have 3 errors log includeing sequential 2 error log" do
-        let(:logfile) { File.expand_path("./spec/support/fixtures/error3.log", Rails.root) }
-        subject { log.recent_errors(3) }
-
-        it "count 3 errors" do
-          subject[0][:subject].should include("3 Address already in use - bind(2)")
-          subject[0][:notes].size.should be 1
-          subject[1][:subject].should include("2 Address already in use - bind(2)")
-          subject[1][:notes].size.should be 2
-          subject[2][:subject].should include("1 Address already in use - bind(2)")
-          subject[2][:notes].size.should be 0
-        end
-      end
-    end
-  end
-
-end

data/spec/models/fluentd_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-
-describe Fluentd do
-  shared_examples_for "path permission" do |column|
-    let(:path) { fluentd.send(column) }
-
-    subject do
-      fluentd.check_permission(column)
-      fluentd.errors
-    end
-
-    context "file exists" do
-      before { FileUtils.touch(path) }
-      after { FileUtils.chmod(0755, path) }
-
-      context "writable" do
-        before { FileUtils.chmod(0600, path) }
-        it { should be_blank }
-      end
-
-      context "not writable" do
-        before { FileUtils.chmod(0400, path) }
-        it { should_not be_blank }
-        it { subject[column].should include(I18n.t('activerecord.errors.messages.lack_write_permission')) }
-      end
-
-      context "not readable" do
-        before { FileUtils.chmod(0200, path) }
-        it { should_not be_blank }
-        it { subject[column].should include(I18n.t('activerecord.errors.messages.lack_read_permission')) }
-      end
-
-      context "is directory" do
-        before { fluentd.send("#{column}=", Rails.root + "tmp") }
-        it { should_not be_blank }
-        it { subject[column].should include(I18n.t('activerecord.errors.messages.is_a_directory')) }
-      end
-    end
-
-    context "file not exists" do
-      let(:dir) { File.dirname(path) }
-      before { FileUtils.rm path }
-      after { FileUtils.chmod_R(0755, dir) }
-
-      context "writable" do
-        before { FileUtils.chmod(0700, dir) }
-        it { should be_blank }
-      end
-
-      context "not writable" do
-        before { FileUtils.chmod(0500, dir) }
-        it { should_not be_blank }
-        it { subject[column].should include(I18n.t('activerecord.errors.messages.lack_write_permission')) }
-      end
-    end
-  end
-
-  let(:fluentd) { build(:fluentd) }
-  after { File.unlink(Fluentd.json_path) if File.exist?(Fluentd.json_path) }
-
-  describe "#valid?" do
-    before do
-      %w(pid_file log_file config_file).each do |column|
-        FileUtils.mkdir_p File.dirname(fluentd.send(column))
-        FileUtils.touch fluentd.send(column)
-      end
-    end
-
-    subject { fluentd }
-
-    describe "variant" do
-      before { fluentd.variant = variant }
-
-      context "fluentd" do
-        let(:variant) { "fluentd_gem" }
-        it { should be_valid }
-      end
-
-      context "foobar (not declared in Fluentd.variants)" do
-        let(:variant) { "foobar" }
-        it { should_not be_valid }
-      end
-    end
-
-    describe "pid_file" do
-      it_should_behave_like "path permission", :pid_file
-    end
-
-    describe "log_file" do
-      it_should_behave_like "path permission", :log_file
-    end
-
-    describe "config_file" do
-      it_should_behave_like "path permission", :config_file
-    end
-  end
-
-  describe "variant" do
-    before { fluentd.variant = variant }
-
-    context "= fluentd_gem" do
-      let(:variant) { "fluentd_gem" }
-      it { fluentd.should be_fluentd_gem }
-      it { fluentd.should_not be_td_agent }
-
-      describe "#load_settings_from_agent_default" do
-        before { fluentd.load_settings_from_agent_default }
-
-        it { fluentd.pid_file == fluentd.agent.class.default_options[:pid_file] }
-        it { fluentd.log_file == fluentd.agent.class.default_options[:log_file] }
-        it { fluentd.config_file == fluentd.agent.class.default_options[:config_file] }
-      end
-    end
-
-    context "= td-agent" do
-      let(:variant) { "td-agent" }
-      it { fluentd.should_not be_fluentd_gem }
-      it { fluentd.should be_td_agent }
-
-      describe "#load_settings_from_agent_default" do
-        before { fluentd.load_settings_from_agent_default }
-
-        it { fluentd.pid_file == fluentd.agent.class.default_options[:pid_file] }
-        it { fluentd.log_file == fluentd.agent.class.default_options[:log_file] }
-        it { fluentd.config_file == fluentd.agent.class.default_options[:config_file] }
-      end
-    end
-  end
-
-  describe "#agent" do
-    before { fluentd.variant = variant }
-    subject { fluentd.agent }
-
-    context "fluentd_gem" do
-      let(:variant) { "fluentd_gem" }
-      it { should be_instance_of(Fluentd::Agent::FluentdGem) }
-    end
-
-    context "td-agent" do
-      let(:variant) { "td-agent" }
-      it { should be_instance_of(Fluentd::Agent::TdAgent) }
-    end
-  end
-
-  describe "#ensure_default_config_file" do
-    subject do
-      fluentd.config_file = config_file
-      fluentd.save
-      fluentd.config_file
-    end
-
-    let(:config_file) { Rails.root + "tmp/test.conf" }
-
-    context "doesn't exists" do
-      before { File.unlink(config_file) if File.exist?(config_file) }
-      it { File.exist?(subject).should be_truthy }
-    end
-
-    context "already exists" do
-      before { FileUtils.touch(config_file) }
-      it { File.exist?(subject).should be_truthy }
-    end
-  end
-end

data/spec/models/plugin_spec.rb

@@ -1,191 +0,0 @@
-require 'spec_helper'
-
-describe Plugin do
-  let(:plugin) { build(:plugin) }
-
-  describe ".installed" do
-    before { FluentGem.stub(:"`").and_return(gem_list) }
-
-    context "fluent-plugin-foo 0.1.2" do
-      let(:target) { Plugin.new(gem_name: "fluent-plugin-foo", version: "0.1.2") }
-      let(:gem_list) { <<-GEM.strip_heredoc }
-        dummy (3.3.3)
-        fluent-plugin-foo (0.1.2)
-        more_dummy (0.0.1)
-      GEM
-
-      it "detect foo plugin" do
-        Plugin.installed.first.inspect.should == target.inspect
-      end
-
-      it "detected foo plugin is marked as installed" do
-        target.should be_installed
-      end
-
-      it "detected foo plugin version to be installed_version" do
-        target.installed_version.should == target.version
-      end
-    end
-  end
-
-  describe "#valid?" do
-    describe "gem_name" do
-      subject { plugin }
-      before { plugin.gem_name = gem_name }
-
-      context "nil is invalid" do
-        let(:gem_name) { nil }
-        it { should_not be_valid }
-      end
-
-      context "something filled is valid" do
-        let(:gem_name) { "foobar" }
-        it { should be_valid }
-      end
-    end
-
-    describe "version" do
-      subject { plugin }
-      before { plugin.version = version }
-
-      context "nil is invalid" do
-        let(:version) { nil }
-        it { should_not be_valid }
-      end
-
-      context "something filled is valid" do
-        let(:version) { "0.0.1" }
-        it { should be_valid }
-      end
-    end
-  end
-
-  describe "#install!" do
-    describe "invoke fluent_gem" do
-      after do
-        plugin.stub(:valid?).and_return(valid)
-        plugin.stub(:installed?).and_return(installed)
-        plugin.install!
-      end
-
-      context "valid" do
-        let(:valid) { true }
-
-        context "installed" do
-          let(:installed) { true }
-          it { FluentGem.should_not_receive(:install) }
-        end
-
-        context "not installed" do
-          let(:installed) { false }
-          it { FluentGem.should_receive(:install) }
-        end
-      end
-
-      context "invalid" do
-        let(:valid) { false }
-
-        context "installed" do
-          let(:installed) { true }
-          it { FluentGem.should_not_receive(:install) }
-        end
-
-        context "not installed" do
-          let(:installed) { false }
-          it { FluentGem.should_not_receive(:installed) }
-        end
-      end
-    end
-
-    context "system command error" do
-      before { FluentGem.should_receive(:system).at_least(1).and_return(false) }
-      subject { expect { plugin.install! } }
-
-      it "raise GemError" do
-        subject.to raise_error(FluentGem::GemError)
-      end
-
-      it "error message contains gem name" do
-        subject.to raise_error(/#{plugin.gem_name}/)
-      end
-    end
-  end
-
-  describe "#uninstall!" do
-    let(:installed_plugin) { build(:plugin, gem_name: "fluent-plugin-foobar") }
-
-    before do
-      installed_plugin.stub(:installed?).and_return(installed)
-    end
-
-    context "installed" do
-      let(:installed) { true } 
-      before { installed_plugin.should_receive(:gem_uninstall) }
-      it { installed_plugin.uninstall! }
-    end
-
-    context "not installed" do
-      let(:installed) { false } 
-      before { installed_plugin.should_not_receive(:gem_uninstall) }
-      it { installed_plugin.uninstall! }
-    end
-  end
-
-  describe "#upgrade!" do
-    let(:installed_plugin) { build(:plugin, gem_name: "fluent-plugin-foobar", version: current_version) }
-    let(:current_version) { "1.0.0" }
-    let(:target_version) { "1.2.0" }
-
-    before do
-      # NOTE: not `plugin.stub` because upgrade! creates new Plugin instance internally
-      installed_plugin.stub(:installed?).and_return(true)
-      FluentGem.stub(:run).and_return(true)
-
-      installed_plugin.should_receive(:uninstall!)
-      FluentGem.should_receive(:install)
-    end
-
-    it { installed_plugin.upgrade!(target_version) }
-  end
-
-  describe "#to_param" do
-    it { plugin.to_param.should == plugin.gem_name }
-  end
-
-  describe "Gem versions" do
-    let(:plugin) { build(:plugin, version: current_version) }
-    let(:current_version) { "1.0.0" }
-    let(:versions) { %w(1.0.1 0.99.1 1.0.0 0.99.0 0.1.0 0.0.3 0.0.2 0.0.1) }
-    let(:authors) { %w(foo bar) }
-    let(:json) do
-      versions.map do |ver|
-        {
-          number: ver,
-          summary: "summary of #{ver}",
-          authors: authors,
-        }
-      end.to_json
-    end
-
-    before do
-      stub_request(:get, plugin.gem_json_url).to_return(body: json)
-    end
-
-    it "latest version is 1.0.1" do
-      plugin.latest_version.should == "1.0.1"
-    end
-    it "1.0.0 is not latest" do
-      plugin.should_not be_latest_version
-      plugin.latest_version.should_not == plugin.version
-    end
-    it "released version is sorted" do
-      plugin.released_versions.should == versions.sort_by{|ver| Gem::Version.new(ver) }.reverse
-    end
-    it "authors" do
-      plugin.authors.should == authors
-    end
-    it "summary" do
-      plugin.summary.should == "summary of #{plugin.version}"
-    end
-  end
-end