rubocop-yast 0.0.4 → 0.0.5

data/spec/builtins_spec.rb

@@ -1,65 +1,567 @@
-# encoding: utf-8
+# Automatically generated -- DO NOT EDIT!
 
 require "spec_helper"
 
-def expect_y2milestone_offense(cop)
-  expect(cop.offenses.size).to eq(1)
-  expect(cop.offenses.first.line).to eq(1)
-  expect(cop.messages).to eq(["Builtin call `y2milestone` is obsolete, " \
-        "use native Ruby function instead."])
-end
+describe "RuboCop-Yast" do
+  describe "Generic Tests:" do
+    it "It reports y2milestone builtin as offense" do
+      code = code_cleanup(<<-EOT)
+        Builtins.y2milestone("foo")
+      EOT
 
-describe RuboCop::Cop::Yast::Builtins do
-  subject(:cop) { described_class.new }
+      cop = RuboCop::Cop::Yast::Builtins.new
+      inspect_source(cop, [code])
 
-  it "reports Builtins.* calls" do
-    inspect_source(cop, ['Builtins.y2milestone("foo")'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages.first).to match(/Builtin call `.*` is obsolete/)
+    end
 
-    expect_y2milestone_offense(cop)
-  end
+    it "It finds builtin in explicit Yast namespace" do
+      code = code_cleanup(<<-EOT)
+        Yast::Builtins.y2milestone("foo")
+      EOT
 
-  it "reports Yast::Builtins.* calls" do
-    inspect_source(cop, ['Yast::Builtins.y2milestone("foo")'])
+      cop = RuboCop::Cop::Yast::Builtins.new
+      inspect_source(cop, [code])
 
-    expect_y2milestone_offense(cop)
-  end
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages.first).to match(/Builtin call `.*` is obsolete/)
+    end
 
-  it "reports ::Yast::Builtins.* calls" do
-    inspect_source(cop, ['::Yast::Builtins.y2milestone("foo")'])
+    it "It finds builtin in explicit ::Yast namespace" do
+      code = code_cleanup(<<-EOT)
+        ::Yast::Builtins.y2milestone("foo")
+      EOT
 
-    expect_y2milestone_offense(cop)
-  end
+      cop = RuboCop::Cop::Yast::Builtins.new
+      inspect_source(cop, [code])
 
-  it "ignores lsort builtin" do
-    inspect_source(cop, ['Builtins.lsort(["foo"])'])
+      expect(cop.offenses.size).to eq(1)
+      expect(cop.messages.first).to match(/Builtin call `.*` is obsolete/)
+    end
 
-    expect(cop.offenses).to be_empty
-  end
+    it "Builtins in the ::Builtins name space are ignored" do
+      code = code_cleanup(<<-EOT)
+        ::Builtins.y2milestone("foo")
+      EOT
 
-  it "ignores ::Builtins calls" do
-    inspect_source(cop, ['::Builtins.y2milestone("foo")'])
+      cop = RuboCop::Cop::Yast::Builtins.new
+      inspect_source(cop, [code])
 
-    expect(cop.offenses).to be_empty
-  end
+      expect(cop.offenses).to be_empty
+    end
+
+    it "Builtins in non Yast name space are ignored" do
+      code = code_cleanup(<<-EOT)
+        Foo::Builtins.y2milestone("foo")
+      EOT
 
-  it "ignores Foo::Builtins calls" do
-    inspect_source(cop, ['Foo::Builtins.y2milestone("foo")'])
+      cop = RuboCop::Cop::Yast::Builtins.new
+      inspect_source(cop, [code])
 
-    expect(cop.offenses).to be_empty
+      expect(cop.offenses).to be_empty
+    end
+
+    it "lsort(), crypt and gettext builtins are allowed" do
+      code = code_cleanup(<<-EOT)
+        Builtins.lsort(["foo"])
+        Builtins.crypt("foo")
+        Builtins.dgettext("domain", "foo")
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      inspect_source(cop, [code])
+
+      expect(cop.offenses).to be_empty
+    end
+
+    it "It does not change unknown builtins" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.foo()
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        Builtins.foo()
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
   end
 
-  it "auto-corrects Builtins.time with ::Time.now.to_i" do
-    new_source = autocorrect_source(cop, "Builtins.time")
-    expect(new_source).to eq("::Time.now.to_i")
+  describe "Builtins.time():" do
+    it "Is trivially converted to `::Time.now.to_i`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.time()
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        ::Time.now.to_i
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
   end
 
-  it 'auto-corrects Builtins.getenv("foo") with ENV["foo"]' do
-    new_source = autocorrect_source(cop, 'Builtins.getenv("foo")')
-    expect(new_source).to eq('ENV["foo"]')
+  describe "Builtins.getenv():" do
+    it "With string literal parameter is translated to ENV equivalent" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.getenv("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        ENV["foo"]
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "Variable as parameter is preserved" do
+      original_code = code_cleanup(<<-EOT)
+        foo = bar
+        Builtins.getenv(foo)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        foo = bar
+        ENV[foo]
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "Any other statement is preserved" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.getenv(Ops.add(foo, bar))
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        ENV[Ops.add(foo, bar)]
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
   end
 
-  it "auto-corrects Builtins.getenv(foo) with ENV[foo]" do
-    new_source = autocorrect_source(cop, "Builtins.getenv(foo)")
-    expect(new_source).to eq("ENV[foo]")
+  describe "Logging:" do
+    it "It translates `y2debug` to `log.debug`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2debug("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.debug "foo"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It translates `y2milestone` to `log.info`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.info "foo"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It translates `y2warning` to `log.warn`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn "foo"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It translates `y2error` to `log.error`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2error("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.error "foo"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It translates `y2security` to `log.error`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2security("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.error "foo"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It translates `y2internal` to `log.fatal`" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2internal("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.fatal "foo"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It adds the include statement only once" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone("foo")
+        Builtins.y2milestone("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.info \"foo\"
+        log.info \"foo\"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts YCP sformat to Ruby interpolation" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone("foo: %1", foo)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.info "foo: \#{foo}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts %% in the format string to simple %" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone("foo: %1%%", foo)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.info "foo: \#{foo}%"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It replaces repeated % placeholders in the format string" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning("%1 %1", foo)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn "\#{foo} \#{foo}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "The % placeholders do not need to start from 1" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning("%2 %2", foo, bar)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn "\#{bar} \#{bar}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "The % placeholders do not need to be in ascending order" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning("%2 %1", foo, bar)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn "\#{bar} \#{foo}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It keeps the original statements in interpolated string" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning("%1", foo + bar)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn "\#{foo + bar}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts a log with string interpolation" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning("foo: \#{foo}")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn "foo: \#{foo}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts a log with a message variable" do
+      original_code = code_cleanup(<<-EOT)
+        msg = "message"
+        Builtins.y2warning(msg)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        msg = "message"
+        log.warn msg
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts a log with function call" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning(msg)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn msg
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It doesn't convert a log with extra parameters" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning(msg, arg1, arg2)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        Builtins.y2warning(msg, arg1, arg2)
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts log with operator call" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2warning(msg1 + msg2)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.warn msg1 + msg2
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It adds logger include to the class definition" do
+      original_code = code_cleanup(<<-EOT)
+        class Foo
+          Builtins.y2error('foo')
+        end
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        class Foo
+          include Yast::Logger
+
+          log.error "foo"
+        end
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It adds logger include with correct indentation" do
+      original_code = code_cleanup(<<-EOT)
+          class Foo
+            Builtins.y2error('foo')
+          end
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+          class Foo
+            include Yast::Logger
+
+            log.error "foo"
+          end
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It does not add the logger include if already present" do
+      original_code = code_cleanup(<<-EOT)
+        class Foo
+          include Yast::Logger
+          Builtins.y2error('foo')
+        end
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        class Foo
+          include Yast::Logger
+          log.error "foo"
+        end
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It adds the logger include after the parent class name if present" do
+      original_code = code_cleanup(<<-EOT)
+        class Foo < Bar
+          Builtins.y2error('foo')
+        end
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        class Foo < Bar
+          include Yast::Logger
+
+          log.error "foo"
+        end
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It adds logger include once to a derived class in a module" do
+      original_code = code_cleanup(<<-EOT)
+        module Yast
+          class TestClass < Module
+            def test
+              Builtins.y2error("foo")
+              Builtins.y2debug("foo")
+            end
+          end
+        end
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        module Yast
+          class TestClass < Module
+            include Yast::Logger
+
+            def test
+              log.error "foo"
+              log.debug "foo"
+            end
+          end
+        end
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It converts the single quoted format string to double quoted" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone('foo: %1', foo)
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.info "foo: \#{foo}"
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It escapes double quotes and interpolations" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone('"\#{foo}"')
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        include Yast::Logger
+        log.info "\\"\\\#{foo}\\""
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It does not convert logging with backtrace" do
+      original_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone(-1, "foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        Builtins.y2milestone(-1, "foo")
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
+
+    it "It does not convert code with a local variable 'log'" do
+      original_code = code_cleanup(<<-EOT)
+        log = 1
+        Builtins.y2milestone("foo")
+      EOT
+
+      translated_code = code_cleanup(<<-EOT)
+        log = 1
+        Builtins.y2milestone("foo")
+      EOT
+
+      cop = RuboCop::Cop::Yast::Builtins.new
+      expect(autocorrect_source(cop, original_code)).to eq(translated_code)
+    end
   end
 end