fluentd-ui 0.1.0

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

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Fluentd::Setting::Common do
+  let(:klass) { Fluentd::Setting::Common }
+
+  describe "class methods" do
+    describe "#booleans" do
+      subject do
+        Class.new do
+          include Fluentd::Setting::Common
+          attr_accessor :bool1, :bool2, :foo
+          booleans :bool1, :bool2
+        end.new
+      end
+
+      it { subject.column_type(:bool1).should == :boolean }
+      it { subject.column_type(:bool2).should == :boolean }
+      it { subject.column_type(:foo).should_not == :boolean }
+    end
+
+    describe "#flags" do
+      subject do
+        Class.new do
+          include Fluentd::Setting::Common
+          attr_accessor :flag1, :flag2, :foo
+          flags :flag1, :flag2
+        end.new
+      end
+
+      it { subject.column_type(:flag1).should == :flag }
+      it { subject.column_type(:flag2).should == :flag }
+      it { subject.column_type(:foo).should_not == :flag }
+    end
+
+    describe "#hidden" do
+      subject do
+        Class.new do
+          include Fluentd::Setting::Common
+          attr_accessor :hide
+          hidden :hide
+        end.new
+      end
+
+      it { subject.column_type(:hide).should == :hidden }
+    end
+
+    describe "#choice" do
+      subject do
+        Class.new do
+          include Fluentd::Setting::Common
+          attr_accessor :choice, :foo
+          choice :choice, %w(a b c)
+        end.new
+      end
+
+      it { subject.column_type(:choice).should == :choice }
+      it { subject.values_of(:choice).should == %w(a b c) }
+      it { subject.column_type(:foo).should_not == :choice }
+    end
+
+    describe "#nested" do
+      before do
+        @child_class = Class.new do
+          include Fluentd::Setting::Common
+        end
+      end
+
+      subject do
+        child = @child_class
+        Class.new do
+          include Fluentd::Setting::Common
+          attr_accessor :child, :foo
+          nested :child, child
+        end.new
+      end
+
+      it { subject.column_type(:child).should == :nested }
+      it { subject.child_class(:child).should == @child_class }
+      it { subject.column_type(:foo).should_not == :nested }
+    end
+  end
+
+  describe "instance methods" do
+    describe "plugin name" do
+      before do
+        klass = Class.new do
+          include Fluentd::Setting::Common
+        end
+        Object.const_set(class_name, klass)
+      end
+      after { Object.send(:remove_const, class_name) }
+      subject { Object.const_get(class_name).new }
+
+      context "InFoo" do
+        let(:class_name) { "InFoo" }
+        it "plugin_type_name == foo" do
+          subject.plugin_type_name.should == "foo"
+        end
+        it "should be input_plugin" do
+          subject.should be_input_plugin
+        end
+      end
+
+      context "OutBar" do
+        let(:class_name) { "OutBar" }
+        it "plugin_type_name == bar" do
+          subject.plugin_type_name.should == "bar"
+        end
+        it "should be output_plugin" do
+          subject.should be_output_plugin
+        end
+      end
+    end
+
+    describe "generate config file" do
+      before do
+        class Child
+          include Fluentd::Setting::Common
+          KEYS = [:child_foo]
+          attr_accessor(*KEYS)
+        end
+        @klass = Class.new do
+          include Fluentd::Setting::Common
+          KEYS = [:key1, :key2, :flag1, :hide, :ch, :child, :string] # FIXME: display "warning: already initialized constant KEYS", but works :(
+          attr_accessor(*KEYS)
+          booleans :key1, :key2
+          flags :flag1
+          hidden :hide
+          choice :ch, %w(foo bar)
+          nested :child, Child
+        end
+      end
+      after { Object.send(:remove_const, :Child) }
+
+      subject { @klass.new(params).to_config("dummy") }
+
+      describe "boolean" do
+        # NOTE: "true" and "false" are the string because the are given by HTTP request
+        let(:params) { {key1: "true", key2: "false"} }
+
+        it { should include("key1 true\n") }
+        it { should include("key2 false\n") }
+      end
+
+      describe "flag" do
+        context "true" do
+          let(:params) { {flag1: "true"} }
+          it { should include("flag1\n") }
+        end
+        context "false" do
+          let(:params) { {flag1: "false"} }
+          it { should_not include("flag1\n") }
+        end
+      end
+
+      describe "hidden" do
+        let(:params) { {hide: "foo"} }
+        it { should include("hide foo\n") }
+      end
+
+      describe "choice" do
+        let(:params) { {ch: "foo"} }
+        it { should include("ch foo\n") }
+      end
+
+      describe "string" do
+        let(:params) { {string: "foobar"} }
+        it { should include("string foobar\n") }
+      end
+
+      describe "nested" do
+        let(:params) { {child: {"0" => { child_foo: "hi" }}} }
+        it { should match(%r!<child>\n\s+child_foo hi\n\s+</child>!) }
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe Fluentd::Setting::InSyslog do
+  let(:klass) { described_class }
+  let(:instance) { klass.new(valid_attributes) }
+  let(:valid_attributes) {
+    {
+      tag: "foo.bar",
+    }
+  }
+
+  describe "#valid?" do
+    it "should be invalid if tag parameter lacked" do
+      params = valid_attributes.dup
+      params.delete(:tag)
+      klass.new(params).should_not be_valid
+    end
+  end
+
+  describe "#plugin_type_name" do
+    subject { instance.plugin_type_name }
+    it { should == "syslog" }
+  end
+
+  describe "#input_plugin" do
+    it { instance.should be_input_plugin }
+    it { instance.should_not be_output_plugin }
+  end
+
+  describe "#to_config" do
+    subject { instance.to_config }
+    it { should include("type syslog") }
+  end
+end
+

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

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Fluentd::Setting::OutMongo do
+  let(:klass) { described_class }
+  let(:instance) { klass.new(valid_attributes) }
+  let(:valid_attributes) {
+    {
+      match: "mongo.*.*",
+      host: "example.com",
+      port: 12345,
+      database: "mongodb",
+      tag_mapped: "true",
+    }
+  }
+
+  describe "#valid?" do
+    it "should be invalid if tag parameter lacked" do
+      params = valid_attributes.dup
+      params.delete(:match)
+      klass.new(params).should_not be_valid
+    end
+  end
+
+  describe "#plugin_type_name" do
+    subject { instance.plugin_type_name }
+    it { should == "mongo" }
+  end
+
+  describe "#input_plugin" do
+    it { instance.should_not be_input_plugin }
+    it { instance.should be_output_plugin }
+  end
+
+  describe "#to_config" do
+    subject { instance.to_config }
+    it { should include("type mongo") }
+    it { should include("tag_mapped") }
+  end
+end
+

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Fluentd::Setting::OutTd do
+  let(:klass) { described_class }
+  let(:instance) { klass.new(valid_attributes) }
+  let(:valid_attributes) {
+    {
+      match: "td.*.*",
+      apikey: "APIKEY",
+      auto_create_table: "true",
+    }
+  }
+
+  describe "#valid?" do
+    it "should be invalid if tag parameter lacked" do
+      params = valid_attributes.dup
+      params.delete(:match)
+      klass.new(params).should_not be_valid
+    end
+  end
+
+  describe "#plugin_type_name" do
+    subject { instance.plugin_type_name }
+    it { should == "tdlog" }
+  end
+
+  describe "#input_plugin" do
+    it { instance.should_not be_input_plugin }
+    it { instance.should be_output_plugin }
+  end
+
+  describe "#to_config" do
+    subject { instance.to_config }
+    it { should include("type tdlog") }
+    it { should include("APIKEY") }
+  end
+end
+

data/spec/models/fluentd_spec.rb

@@ -0,0 +1,166 @@
+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.get(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.get(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.get(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.get(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
+      skip "Circle CI file operations are unstable :(" if ENV["CIRCLECI"]
+
+      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