fluentd-ui 1.0.0.alpha.2 → 1.0.0.alpha.3

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

@@ -1,178 +0,0 @@
-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
-          const_set(:KEYS, [:key1, :key2, :flag1, :hide, :ch, :child, :string])
-          attr_accessor(*const_get(: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/out_td_spec.rb

@@ -1,38 +0,0 @@
-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
-