fluentd-ui 1.0.0.beta.1 → 1.0.0

data/test/models/fluentd/setting/out_stdout_test.rb

@@ -0,0 +1,32 @@
+require "test_helper"
+
+require "fluent/plugin/buf_file"
+
+module Fluentd::Setting
+  class OutStdoutTest < ActiveSupport::TestCase
+    setup do
+      @klass = Fluentd::Setting::OutStdout
+      @instance = @klass.new({})
+    end
+
+    test "#valid?" do
+      assert do
+        @instance.valid?
+      end
+    end
+
+    test "#plugin_name" do
+      assert_equal("stdout", @instance.plugin_name)
+    end
+
+    test "#plugin_type" do
+      assert_equal("output", @instance.plugin_type)
+    end
+
+    test "#to_config" do
+      assert do
+        @instance.to_config.to_s.include?("@type stdout")
+      end
+    end
+  end
+end

data/test/models/fluentd/setting/out_tdlog_test.rb

@@ -0,0 +1,60 @@
+require "test_helper"
+require "fluent/plugin/buf_file"
+
+module Fluentd::Setting
+  class OutTdlogTest < ActiveSupport::TestCase
+    setup do
+      @klass = Fluentd::Setting::OutTdlog
+      @valid_attributes = {
+        pattern: "td.*.*",
+        apikey: "APIKEY",
+        auto_create_table: "true",
+        buffer: {
+          "0" => {
+            type: "file",
+            path: "/tmp/buffer"
+          }
+        }
+      }
+      @instance = @klass.new(@valid_attributes)
+    end
+
+    sub_test_case "#valid?" do
+      test "valid" do
+        assert do
+          @instance.valid?
+        end
+      end
+
+      test "invalid if apikey is missing" do
+        params = @valid_attributes.dup
+        params.delete(:apikey)
+        instance = @klass.new(params)
+        assert_false(instance.valid?)
+        assert_equal(["'apikey' parameter is required"], instance.errors.full_messages)
+      end
+    end
+
+    test "#plugin_name" do
+      assert_equal("tdlog", @instance.plugin_name)
+    end
+
+    test "#plugin_type" do
+      assert_equal("output", @instance.plugin_type)
+    end
+
+    test "#to_config" do
+      expected = <<-CONFIG.strip_heredoc
+        <match td.*.*>
+          @type tdlog
+          apikey APIKEY
+          <buffer>
+            @type file
+            path /tmp/buffer
+          </buffer>
+        </match>
+      CONFIG
+      assert_equal(expected, @instance.to_config.to_s)
+    end
+  end
+end

data/test/models/fluentd_log_test.rb

@@ -0,0 +1,140 @@
+require "test_helper"
+
+class FluentdLogTest < ActiveSupport::TestCase
+  sub_test_case "#read" do
+    setup do
+      @logfile = Rails.root.join("tmp", "dummylog").to_s
+      @log = FluentdLog.new(@logfile)
+    end
+
+    test "compatible with utf-8" do
+      content = "utf8あいう\n"
+      File.write(@logfile, content)
+      assert_equal(content, @log.read)
+    end
+
+    test "incompatible with utf-8" do
+      content = "eucあいう\n".encode('euc-jp').force_encoding('ascii-8bit')
+      File.open(@logfile, "wb") {|file| file.write(content) }
+      assert_equal(content, @log.read)
+    end
+  end
+
+  sub_test_case "#tail" do
+    setup do
+      @logfile = Rails.root.join("tmp", "dummylog").to_s
+      @log = FluentdLog.new(@logfile)
+      File.open(@logfile, "wb") do |file|
+        5.times do |n|
+          file.puts(n)
+        end
+      end
+    end
+
+    data("tail(5)" => [5, %w(4 3 2 1 0)],
+         "tail(3)" => [3, %w(4 3 2)],
+         "tail(99)" => [99, %w(4 3 2 1 0)])
+    test "5 line log" do |(limit, expected)|
+      assert_equal(@log.tail(limit), expected)
+    end
+  end
+
+  sub_test_case "#logged_errors" do
+    data("have 0 error log" => "error0.log",
+         "have error log" => "error2.log")
+    test "#last_error_message" do |path|
+      logfile = fixture_path(path)
+      log = FluentdLog.new(logfile)
+      if path == "error0.log"
+        assert do
+          log.last_error_message.empty?
+        end
+      else
+        assert_equal(log.last_error_message, log.recent_errors(1).first[:subject])
+      end
+    end
+
+    sub_test_case "#errors_since" do
+      setup do
+        @logged_time = Time.parse("2014-05-27")
+        @now = Time.parse("2014-05-29")
+        Timecop.freeze(@now)
+      end
+
+      teardown do
+        Timecop.return
+      end
+
+      test "have no errors" do
+        log = FluentdLog.new(fixture_path("error0.log"))
+        assert do
+          log.errors_since(100.days.ago).empty?
+        end
+      end
+
+      sub_test_case "have errors" do
+        setup do
+          @log = FluentdLog.new(fixture_path("error2.log"))
+        end
+
+        test "unreachable since" do
+          assert do
+            @log.errors_since(0.days.ago).empty?
+          end
+        end
+
+        test "reachable since" do
+          errors = @log.errors_since(100.days.ago)
+          assert_equal("unexpected error error_class=Errno::EADDRINUSE error=#<Errno::EADDRINUSE: Address already in use - bind(2) for \"0.0.0.0\" port 24224>",
+                       errors[0][:subject].slice(/\[error\]: (.+)/, 1))
+          assert do
+            Time.parse(errors[0][:subject]) >= Time.parse(errors[1][:subject])
+          end
+        end
+      end
+    end
+
+    sub_test_case "recent_errors" do
+      test "have 0 error log" do
+        log = FluentdLog.new(fixture_path("error0.log"))
+        assert do
+          log.recent_errors(2).empty?
+        end
+      end
+
+      sub_test_case "have 2 error log" do
+        setup do
+          @log = FluentdLog.new(fixture_path("error2.log"))
+        end
+
+        data("limit=1" => 1,
+             "limit=2" => 2)
+        test "limit" do |limit|
+          assert_equal(limit, @log.recent_errors(limit).length)
+        end
+
+        test "contains stack trace" do
+          errors = @log.recent_errors(2)
+          assert_equal("unexpected error error_class=Errno::EADDRINUSE error=#<Errno::EADDRINUSE: Address already in use - bind(2) for \"0.0.0.0\" port 24224>",
+                       errors[0][:subject].slice(/\[error\]: (.+)/, 1))
+          assert do
+            Time.parse(errors[0][:subject]) >= Time.parse(errors[1][:subject])
+          end
+        end
+      end
+
+      sub_test_case "have 3 errors including sequential 2 error log" do
+        test "count 3 errors" do
+          log = FluentdLog.new(fixture_path("error3.log"))
+          errors = log.recent_errors(3)
+          assert_equal(errors[0][:subject].slice(/::EADDRINUSE: (\d) Address already in use/, 1), "3")
+          assert_equal(errors[0][:notes].size, 1)
+          assert_equal(errors[1][:subject].slice(/::EADDRINUSE: (\d) Address already in use/, 1), "2")
+          assert_equal(errors[1][:notes].size, 2)
+          assert_equal(errors[2][:subject].slice(/::EADDRINUSE: (\d) Address already in use/, 1), "1")
+          assert_equal(errors[2][:notes].size, 0)
+        end
+      end
+    end
+  end
+end

data/test/models/fluentd_test.rb

@@ -0,0 +1,185 @@
+require "test_helper"
+
+class FluentdTest < ActiveSupport::TestCase
+  module PathPermission
+    def self.included(base)
+      base.class_eval do
+        setup do
+          setup_target
+        end
+
+        sub_test_case "file exists" do
+          setup do
+            FileUtils.touch(@path)
+          end
+
+          teardown do
+            FileUtils.rm_f(@path)
+          end
+
+          test "writable" do
+            FileUtils.chmod(0600, @path)
+            @fluentd.check_permission(@column)
+            assert do
+              @fluentd.errors.blank?
+            end
+          end
+
+          test "not writable" do
+            FileUtils.chmod(0400, @path)
+            @fluentd.check_permission(@column)
+            assert do
+              @fluentd.errors.present?
+            end
+            assert_equal(I18n.t('activerecord.errors.messages.lack_write_permission'), @fluentd.errors[@column].first)
+          end
+
+          test "not readable" do
+            FileUtils.chmod(0200, @path)
+            @fluentd.check_permission(@column)
+            assert do
+              @fluentd.errors.present?
+            end
+            assert_equal(I18n.t('activerecord.errors.messages.lack_read_permission'), @fluentd.errors[@column].first)
+          end
+
+          test "is directory" do
+            @fluentd.__send__("#{@column}=", Rails.root + "tmp")
+            @fluentd.check_permission(@column)
+            assert do
+              @fluentd.errors.present?
+            end
+            assert_equal(I18n.t('activerecord.errors.messages.is_a_directory'), @fluentd.errors[@column].first)
+          end
+        end
+
+        sub_test_case "file not exists" do
+          setup do
+            @dir = File.dirname(@path)
+            FileUtils.rm_f(@path)
+          end
+
+          teardown do
+            FileUtils.chmod_R(0755, @dir)
+          end
+
+          test "writable" do
+            FileUtils.chmod(0700, @dir)
+            @fluentd.check_permission(@column)
+            assert do
+              @fluentd.errors.blank?
+            end
+          end
+
+          test "not writable" do
+            FileUtils.chmod(0500, @dir)
+            @fluentd.check_permission(@column)
+            assert do
+              @fluentd.errors.present?
+            end
+            assert_equal(I18n.t('activerecord.errors.messages.lack_write_permission'), @fluentd.errors[@column].first)
+          end
+        end
+      end
+    end
+  end
+
+  setup do
+    @fluentd = FactoryBot.build(:fluentd)
+  end
+
+  teardown do
+    File.unlink(Fluentd.json_path) if File.exist?(Fluentd.json_path)
+  end
+
+  sub_test_case "#valid?" do
+    setup 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
+
+    data("fluentd" => ["fluentd_gem", true],
+         "not declared in Fluentd.variants" => ["foobar", false])
+    test "variant" do |(variant, result)|
+      @fluentd.variant = variant
+      assert_equal(result, @fluentd.valid?)
+    end
+
+    sub_test_case "pid_file" do
+      def setup_target
+        @column = :pid_file
+        @path = @fluentd.pid_file
+      end
+      include PathPermission
+    end
+
+    sub_test_case "log_file" do
+      def setup_target
+        @column = :log_file
+        @path = @fluentd.log_file
+      end
+      include PathPermission
+    end
+
+    sub_test_case "config_file" do
+      def setup_target
+        @column = :config_file
+        @path = @fluentd.config_file
+      end
+      include PathPermission
+    end
+  end
+
+  data("fluentd_gem" => { variant: "fluentd_gem", fluentd_gem?: true },
+       "td-agent" => { variant: "td-agent", fluentd_gem?: false })
+  test "variant" do |data|
+    @fluentd.variant = data[:variant]
+    assert_equal(data[:fluentd_gem?], @fluentd.fluentd_gem?)
+    @fluentd.load_settings_from_agent_default
+    expected = {
+      pid_file: @fluentd.agent.class.default_options[:pid_file],
+      log_file: @fluentd.agent.class.default_options[:log_file],
+      config_file: @fluentd.agent.class.default_options[:config_file]
+    }
+    actual = {
+      pid_file: @fluentd.pid_file,
+      log_file: @fluentd.log_file,
+      config_file: @fluentd.config_file,
+    }
+    assert_equal(expected, actual)
+  end
+
+  data("fluentd_gem" => ["fluentd_gem", Fluentd::Agent::FluentdGem],
+       "td-agent" => ["td-agent", Fluentd::Agent::TdAgent])
+  test "#agent" do |(variant, klass)|
+    @fluentd.variant = variant
+    assert do
+      @fluentd.agent.instance_of?(klass)
+    end
+  end
+
+  sub_test_case "#ensure_default_config_file" do
+    setup do
+      @config_file = Rails.root + "tmp/test.conf"
+      @fluentd.config_file = @config_file
+    end
+
+    test "doesn't exist" do
+      File.unlink(@config_file) if File.exist?(@config_file)
+      @fluentd.save
+      assert do
+        File.exist?(@fluentd.config_file)
+      end
+    end
+
+    test "already exist" do
+      FileUtils.touch(@config_file)
+      @fluentd.save
+      assert do
+        File.exist?(@fluentd.config_file)
+      end
+    end
+  end
+end

data/test/models/plugin_test.rb

@@ -0,0 +1,144 @@
+require "test_helper"
+
+class PluginTest < ActiveSupport::TestCase
+  setup do
+    @plugin = FactoryBot.build(:plugin)
+  end
+
+  sub_test_case ".installed" do
+    setup do
+      gem_list = <<-GEM_LIST.strip_heredoc
+        dummy (3.3.3)
+        fluent-plugin-foo (0.1.2)
+        more_dummy (0.0.1)
+      GEM_LIST
+      stub(FluentGem).gem { "gem" }
+      stub(FluentGem).__double_definition_create__.call(:`, "gem list 2>&1") { gem_list }
+      @target = Plugin.new(gem_name: "fluent-plugin-foo", version: "0.1.2")
+    end
+
+    test "detect foo plugin" do
+      assert_equal(@target.inspect, Plugin.installed.first.inspect)
+    end
+
+    test "detected foo plugin is marked as installed" do
+      assert do
+        @target.installed?
+      end
+    end
+
+    test "detected foo plugin version to be installed_version" do
+      assert_equal(@target.version, @target.installed_version)
+    end
+  end
+
+  sub_test_case "#valid?" do
+    data("nil is invalid" => [nil, false],
+         "something filled is valid" => ["foobar", true])
+    test "gem_name" do |(name, is_valid)|
+      @plugin.gem_name = name
+      assert_equal(is_valid, @plugin.valid?)
+    end
+
+    data("nil is invalid" => [nil, false],
+         "something filled is valid" => ["0.0.1", true])
+    test "version" do |(version, is_valid)|
+      @plugin.version = version
+      assert_equal(is_valid, @plugin.valid?)
+    end
+  end
+
+  sub_test_case "#install!" do
+    def install_plugin(is_valid, is_installed)
+      stub(@plugin).valid? { is_valid }
+      stub(@plugin).installed? { is_installed }
+      @plugin.install!
+    end
+
+
+    data("installed" => [true, 0],
+         "not installed" => [false, 1])
+    test "valid" do |(is_installed, n)|
+      mock(FluentGem).install(anything, "--no-ri", "--no-rdoc", "-v", anything).times(n) {}
+      install_plugin(true, is_installed)
+    end
+
+    data("installed" => [true, :install],
+         "not installed" => [false, :installed])
+    test "invalid" do |(is_installed, method)|
+      mock(FluentGem).__send__(method).times(0)
+      install_plugin(false, is_installed)
+    end
+
+    test "system command error" do
+      stub(FluentGem).gem { "gem" }
+      mock(FluentGem).system("gem", "install", "fluent-plugin-dummy", "--no-ri", "--no-rdoc", "-v", "1.2.3").at_least(1) { false }
+      assert_raise(FluentGem::GemError.new("failed command: `gem install fluent-plugin-dummy --no-ri --no-rdoc -v 1.2.3`")) do
+        @plugin.install!
+      end
+    end
+  end
+
+  data("installed" => [true, 1],
+       "uninstalled" => [false, 0])
+  test "#uninstall!" do |(is_installed, n)|
+    installed_plugin = FactoryBot.build(:plugin, gem_name: "fluent-plugin-foobar")
+    mock(installed_plugin).installed? { is_installed }
+    mock(installed_plugin).gem_uninstall.times(n) {}
+    installed_plugin.uninstall!
+  end
+
+  test "#upgrade!" do
+    installed_plugin = FactoryBot.build(:plugin, gem_name: "fluent-plugin-foobar", version: "1.0.0")
+    stub(installed_plugin).installed? { true }
+    stub(FluentGem).gem { "gem" }
+    stub(FluentGem).run("gem", "install", "fluent-plugin-foobar", "--no-ri", "--no-rdoc", "-v", "1.2.0") { true }
+    mock(installed_plugin).uninstall! {}
+    mock(FluentGem).install("fluent-plugin-foobar", "--no-ri", "--no-rdoc", "-v", "1.2.0") {}
+    installed_plugin.upgrade!("1.2.0")
+  end
+
+  test "#to_param" do
+    assert do
+      @plugin.to_param == @plugin.gem_name
+    end
+  end
+
+  sub_test_case "Gem version" do
+    setup do
+      @plugin = FactoryBot.build(:plugin, version: "1.0.0")
+      @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)
+      @authors = %w(foo bar)
+      json_response = @versions.map do |version|
+        {
+          number: version,
+          summary: "summary of #{version}",
+          authors: @authors
+        }
+      end.to_json
+      stub_request(:get, @plugin.gem_json_url).to_return(body: json_response)
+    end
+
+    test "latest version is 1.0.0" do
+      assert_equal("1.0.1", @plugin.latest_version)
+    end
+
+    test "1.0.0 is not lates" do
+      assert do
+        !@plugin.latest_version?
+      end
+    end
+
+    test "released_versions is sorted" do
+      assert_equal(@versions.sort_by{|ver| Gem::Version.new(ver) }.reverse, @plugin.released_versions)
+    end
+
+    test "authors" do
+      assert_equal(@authors, @plugin.authors)
+    end
+
+    test "summary" do
+      assert_equal("summary of #{@plugin.version}", @plugin.summary)
+    end
+  end
+end