Hello community, here is the log from the commit of package yast2-tune for openSUSE:Factory checked in at 2016-07-24 19:42:21 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/yast2-tune (Old) and /work/SRC/openSUSE:Factory/.yast2-tune.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "yast2-tune" Changes: -------- --- /work/SRC/openSUSE:Factory/yast2-tune/yast2-tune.changes 2016-06-13 21:50:33.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.yast2-tune.new/yast2-tune.changes 2016-07-24 19:42:23.000000000 +0200 @@ -1,0 +2,7 @@ +Mon Jul 11 12:24:21 UTC 2016 - [email protected] + +- Prevent scheduler settings to be removed during installation + (bsc#968192) +- 3.1.9 + +------------------------------------------------------------------- Old: ---- yast2-tune-3.1.8.tar.bz2 New: ---- yast2-tune-3.1.9.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ yast2-tune.spec ++++++ --- /var/tmp/diff_new_pack.odUqN4/_old 2016-07-24 19:42:23.000000000 +0200 +++ /var/tmp/diff_new_pack.odUqN4/_new 2016-07-24 19:42:23.000000000 +0200 @@ -17,7 +17,7 @@ Name: yast2-tune -Version: 3.1.8 +Version: 3.1.9 Release: 0 BuildRoot: %{_tmppath}/%{name}-%{version}-build ++++++ yast2-tune-3.1.8.tar.bz2 -> yast2-tune-3.1.9.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/.coveralls.yml new/yast2-tune-3.1.9/.coveralls.yml --- old/yast2-tune-3.1.8/.coveralls.yml 1970-01-01 01:00:00.000000000 +0100 +++ new/yast2-tune-3.1.9/.coveralls.yml 2016-07-14 09:51:43.000000000 +0200 @@ -0,0 +1 @@ +service_name: travis-ci diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/.travis.yml new/yast2-tune-3.1.9/.travis.yml --- old/yast2-tune-3.1.8/.travis.yml 2016-06-09 17:25:50.000000000 +0200 +++ new/yast2-tune-3.1.9/.travis.yml 2016-07-14 09:51:43.000000000 +0200 @@ -5,12 +5,9 @@ # disable rvm, use system Ruby - rvm reset - wget https://raw.githubusercontent.com/yast/yast-devtools/SLE-12-GA/travis-tools/travis_setup.sh - - sh ./travis_setup.sh -p "rake yast2-devtools yast2-testsuite yast2" -g "yast-rake gettext" + - sh ./travis_setup.sh -p "rake yast2-devtools yast2-testsuite yast2 yast2-bootloader yast2-storage" -g "yast-rake gettext rspec:3.3.0 simplecov coveralls" script: - rake check:syntax - rake check:pot - - make -f Makefile.cvs - - make - - sudo make install - - make check - + - COVERAGE=1 rake test:unit + - sudo rake install diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/package/yast2-tune.changes new/yast2-tune-3.1.9/package/yast2-tune.changes --- old/yast2-tune-3.1.8/package/yast2-tune.changes 2016-06-09 17:25:50.000000000 +0200 +++ new/yast2-tune-3.1.9/package/yast2-tune.changes 2016-07-14 09:51:43.000000000 +0200 @@ -1,4 +1,11 @@ ------------------------------------------------------------------- +Mon Jul 11 12:24:21 UTC 2016 - [email protected] + +- Prevent scheduler settings to be removed during installation + (bsc#968192) +- 3.1.9 + +------------------------------------------------------------------- Wed Jun 1 17:28:56 UTC 2016 - [email protected] - Removed devel-doc package (fate#320356) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/package/yast2-tune.spec new/yast2-tune-3.1.9/package/yast2-tune.spec --- old/yast2-tune-3.1.8/package/yast2-tune.spec 2016-06-09 17:25:50.000000000 +0200 +++ new/yast2-tune-3.1.9/package/yast2-tune.spec 2016-07-14 09:51:43.000000000 +0200 @@ -17,7 +17,7 @@ Name: yast2-tune -Version: 3.1.8 +Version: 3.1.9 Release: 0 BuildRoot: %{_tmppath}/%{name}-%{version}-build diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/src/modules/SystemSettings.rb new/yast2-tune-3.1.9/src/modules/SystemSettings.rb --- old/yast2-tune-3.1.8/src/modules/SystemSettings.rb 2016-06-09 17:25:50.000000000 +0200 +++ new/yast2-tune-3.1.9/src/modules/SystemSettings.rb 2016-07-14 09:51:43.000000000 +0200 @@ -15,210 +15,295 @@ class SystemSettingsClass < Module include Yast::Logger + # Initialize the module def main textdomain "tune" - Yast.import "Service" + Yast.import "Bootloader" Yast.import "Mode" # Internal Data - @ENABLE_SYSRQ = nil - - @elevator = nil - # Internal Data - - @modified = false + @enable_sysrq = nil + @kernel_sysrq = nil + @sysctl_sysrq = nil + @elevator = nil + @modified = false end + # Known values of the 'elevator' variable + ELEVATORS = ["cfq", "noop", "deadline"].freeze + + # Return the possible values to be used as elevators/schedulers + # + # @return [Array<String>] Know elevators/schedulers + # + # @see ELEVATORS def GetPossibleElevatorValues - # here are listed all known values of the 'elevator' variable - ["cfq", "noop", "deadline"] + ELEVATORS end + # Determine if the module was modified def Modified - Builtins.y2milestone("Modified: %1", @modified) + log.info("Modified: #{@modified}") @modified end + # Read system settings + # + # @see #read_sysrq + # @see #read_scheduler def Read - @ENABLE_SYSRQ = Convert.to_string( - SCR.Read(path(".etc.sysctl_conf.\"kernel.sysrq\"")) - ) - Builtins.y2milestone("SysRq enabled: %1", @ENABLE_SYSRQ) - - current_sysrq = Convert.to_string( - SCR.Read(path(".target.string"), "/proc/sys/kernel/sysrq") - ) - - # read just the first line - current_sysrq = Ops.get(Builtins.splitstring(current_sysrq, "\n"), 0, "") - - if @ENABLE_SYSRQ != nil && current_sysrq != @ENABLE_SYSRQ - Builtins.y2warning( - "SysRq mismatch: sysconfig value: '%1', current: '%2'", - @ENABLE_SYSRQ, - current_sysrq - ) - end - - # display the current value if it not configured - @ENABLE_SYSRQ = current_sysrq if @ENABLE_SYSRQ == nil - - # I have to admit that this is very ugly but it is here - # to avoid of the very long starting time of the yast module - # because the Storage module (which is imported by the Bootloader (imported by the SystemSettings module)) - # has a Read() function call in its constructor. - Yast.import "Bootloader" + read_sysrq + read_scheduler + @modified = false + true + end - if Mode.normal - # runtime - read the settings - Bootloader.Read - end + # Activate settings + # + # @see #activate_sysrq + # @see #activate_scheduler + def Activate + activate_sysrq + activate_scheduler + true + end - # get 'elevator' option from the default section - elevator_parameter = Bootloader.kernel_param(:common, "elevator") + # Write settings to system configuration + def Write + write_sysrq + write_scheduler + end - Builtins.y2milestone("elevator_parameter: %1", elevator_parameter) + # Return the kernel IO scheduler + # + # The scheduler is specified as the 'elevator' kernel parameter. + # If not scheduler is set, it will return an empty string. + # + # @return [String] IO scheduler name or empty string if not set + def GetIOScheduler + @elevator + end - # Variable is not set - if elevator_parameter == :missing - @elevator = "" - # Variable is set but has not parameter - elsif elevator_parameter == :present - Builtins.y2warning("'elevator' variable has to have some value") - @elevator = "" - # Variable is set but hasn't any known value - elsif !Builtins.contains( - GetPossibleElevatorValues(), - Convert.to_string(elevator_parameter) - ) - Builtins.y2warning( - "'elevator' variable has to have a value from %1 instead of being set to %2", - GetPossibleElevatorValues(), - elevator_parameter - ) - @elevator = "" - # Variable is OK + # Set IO scheduler + # + # @param scheduler [String] IO scheduler + def SetIOScheduler(scheduler) + # empty string = use the default scheduler + if valid_scheduler?(scheduler) || scheduler == "" + if GetIOScheduler() != scheduler + @modified = true + @elevator = scheduler + end else - @elevator = Convert.to_string(elevator_parameter) + log.error("unknown IO scheduler '#{scheduler}', use: #{GetPossibleElevatorValues()}") end - Builtins.y2milestone("Global IO scheduler: %1", @elevator) + nil + end - true + # Determine if SysRq keys are enabled + # + # @return [Boolean] true if they're enabled; false otherwise. + def GetSysRqKeysEnabled + !(enable_sysrq.nil? || enable_sysrq == "0") end - def Activate - if @ENABLE_SYSRQ != nil && Builtins.regexpmatch(@ENABLE_SYSRQ, "^[0-9]+$") - Builtins.y2milestone("Activating SysRq config: %1", @ENABLE_SYSRQ) - SCR.Execute( - path(".target.bash"), - Builtins.sformat("echo '%1' > /proc/sys/kernel/sysrq", @ENABLE_SYSRQ) - ) - else - Builtins.y2warning( - "Not activating invalid ENABLE_SYSRQ value: %1", - @ENABLE_SYSRQ - ) + # Set SysRq keys status + # + # @param value [Boolean] true to enable them; false to disable + def SetSysRqKeysEnabled(value) + if value.nil? + log.warn("enable_sysrq should be 'true' or 'false'") + return end - if @elevator != nil - Yast.import "Bootloader" - new_elevator = @elevator == "" ? :missing : @elevator - - Builtins.y2milestone("Activating scheduler: %1", new_elevator) - # set the scheduler - Bootloader.modify_kernel_params("elevator" => new_elevator) - - # activate the scheduler for all disk devices - if new_elevator != :missing - Dir["/sys/block/*/queue/scheduler"].each do |f| - log.info "Activating scheduler '#{new_elevator}' for device #{f}" - File.write(f, new_elevator) - end - end + value_string = value ? "1" : "0" + if value_string != enable_sysrq + @modified = true + self.enable_sysrq = value_string end - true + nil end + publish function: :GetPossibleElevatorValues, type: "list <string> ()" + publish function: :Modified, type: "boolean ()" + publish function: :Read, type: "boolean ()" + publish function: :Activate, type: "boolean ()" + publish function: :Write, type: "boolean ()" + publish function: :GetIOScheduler, type: "string ()" + publish function: :SetIOScheduler, type: "void (string)" + publish function: :GetSysRqKeysEnabled, type: "boolean ()" + publish function: :SetSysRqKeysEnabled, type: "void (boolean)" + + protected + + # Return configuration for SysRq keys + # + # This is the value that will be written when #Write is called. If you want tools + # get the real value from the system, check #kernel_sysrq and #sysctl_sysrq. + # + # @return [String] Configuration value; returns an empty string if it's not set. + # + # @see Write + # @see kernel_sysrq + # @see sysctl_sysrq + attr_reader :enable_sysrq + + # Set sysctl configuration value for SysRq keys + # + # The value is not written until #Write is called. + # + # @param value [String] Configuration value + # + # @see Write + def enable_sysrq=(value) + log.info("SysRq was set to #{value}") + @enable_sysrq = value + end - def Write - # writing SysRq settings - if @ENABLE_SYSRQ != nil && Builtins.regexpmatch(@ENABLE_SYSRQ, "^[0-9]+$") - # save the SysRq setting - Builtins.y2milestone("Saving ENABLE_SYSRQ: %1", @ENABLE_SYSRQ) - SCR.Write(path(".etc.sysctl_conf.\"kernel.sysrq\""), @ENABLE_SYSRQ) - SCR.Write(path(".etc.sysctl_conf"), nil) - else - Builtins.y2warning( - "Not writing invalid ENABLE_SYSRQ value: %1", - @ENABLE_SYSRQ - ) - end + KERNEL_SYSRQ_FILE = "/proc/sys/kernel/sysrq".freeze - # the bootloader configuration is written at the end of the first stage - if Mode.normal - # write the elevator setting - Yast.import "Bootloader" - Bootloader.Write - end + # Return kernel configuration value for SysRq keys + # + # The value is read from /proc/sys/kernel/sysrq + # + # @return [String] Configuration value; returns an empty string if it's not set. + def kernel_sysrq + return @kernel_sysrq if @kernel_sysrq + content = File.exist?(KERNEL_SYSRQ_FILE) ? File.read(KERNEL_SYSRQ_FILE) : "" + @kernel_sysrq = content.split("\n")[0] || "" + end - true + # Return sysctl configuration value for SysRq keys + # + # @return [String] Configuration value; returns an empty string if it's not set. + def sysctl_sysrq + return @sysctl_sysrq if @sysctl_sysrq + @sysctl_sysrq = SCR.Read(path(".etc.sysctl_conf.\"kernel.sysrq\"")) + log.info("SysRq enabled: #{@sysctl_sysrq}") + @sysctl_sysrq end - # Kernel param 'elevator' - def GetIOScheduler - @elevator + # Determine if a string is a valid scheduler name + # + # @return [Boolean] true if it's valid; false otherwise. + def valid_scheduler?(elevator) + GetPossibleElevatorValues().include?(elevator) end - def SetIOScheduler(io_scheduler) - # empty string = use the default scheduler - if Builtins.contains(GetPossibleElevatorValues(), io_scheduler) || - io_scheduler == "" - @modified = true if @elevator != io_scheduler + # Determine the current scheduler from the system + # + # @return [String] IO Scheduler name; if it's not valid/set, it will return an empty string + def current_elevator + # get 'elevator' option from the default section + elevator_parameter = Bootloader.kernel_param(:common, "elevator") + log.info("elevator_parameter: #{elevator_parameter}") - @elevator = io_scheduler - else - Builtins.y2error( - "unknown IO scheduler '%1', use: %2", - io_scheduler, - GetPossibleElevatorValues() + if elevator_parameter == :missing # Variable is not set + "" + elsif elevator_parameter == :present # Variable is set but has not parameter + log.info("'elevator' variable has to have some value") + "" + elsif !valid_scheduler?(elevator_parameter.to_s) # Variable is set but hasn't any known value + log.warn( + format("'elevator' variable has to have a value from %s instead of being set to %s", + GetPossibleElevatorValues(), + elevator_parameter + ) ) + "" + else + elevator_parameter.to_s end - - nil end - def GetSysRqKeysEnabled - @ENABLE_SYSRQ != nil && @ENABLE_SYSRQ != "0" + # Activate SysRq keys configuration + # + # @see enable_sysrq + def activate_sysrq + if enable_sysrq.nil? || enable_sysrq !~ /\A[0-9]\z/ + log.warn("Not activating invalid ENABLE_SYSRQ value: #{enable_sysrq}") + return + end + + log.info("Activating SysRq config: #{enable_sysrq}") + File.write(KERNEL_SYSRQ_FILE, "#{enable_sysrq}\n") end - def SetSysRqKeysEnabled(enable_sysrq) - if enable_sysrq == nil - Builtins.y2warning("enable_sysrq should be 'true' or 'false'") - return + # Activate IO scheduler + # + # @see activate_scheduler + def activate_scheduler + return unless GetIOScheduler() + + new_elevator = GetIOScheduler() == "" ? :missing : GetIOScheduler() + log.info("Activating scheduler: #{new_elevator}") + # set the scheduler + Bootloader.modify_kernel_params("elevator" => new_elevator) + # set bootloader configuration as 'changed' (bsc#968192) + Bootloader.proposed_cfg_changed = true + + # activate the scheduler for all disk devices + return if new_elevator == :missing + Dir["/sys/block/*/queue/scheduler"].each do |f| + log.info("Activating scheduler '#{new_elevator}' for device #{f}") + File.write(f, new_elevator) end + end - enable_sysrq_string = enable_sysrq ? "1" : "0" + # Read IO scheduler configuration updating the module's value + # + # @see Read + def read_scheduler + # Read bootloader settings in normal mode + Bootloader.Read if Mode.normal + + # Set IO scheduler + SetIOScheduler(current_elevator) + log.info("Global IO scheduler: #{GetIOScheduler()}") + end - @modified = true if @ENABLE_SYSRQ != enable_sysrq_string + # Read SysRq keys configuration updating the module's value + # + # @see Read + def read_sysrq + if kernel_sysrq != sysctl_sysrq + log.warn( + format("SysRq mismatch: sysconfig value: '%s', current: '%s'", sysctl_sysrq, kernel_sysrq) + ) + end - @ENABLE_SYSRQ = enable_sysrq_string - Builtins.y2milestone("SysRq was set to %1", @ENABLE_SYSRQ) + # display the current value if it not configured + self.enable_sysrq = sysctl_sysrq || kernel_sysrq + end - nil + # Write SysRq keys settings + # + # @see Write + def write_sysrq + if enable_sysrq.nil? || enable_sysrq !~ /\A[0-9]\z/ + log.warn("Not writing invalid ENABLE_SYSRQ value: #{enable_sysrq}") + return + end + + log.info("Saving ENABLE_SYSRQ: #{enable_sysrq}") + SCR.Write(path(".etc.sysctl_conf.\"kernel.sysrq\""), enable_sysrq) + SCR.Write(path(".etc.sysctl_conf"), nil) end - publish :function => :GetPossibleElevatorValues, :type => "list <string> ()" - publish :function => :Modified, :type => "boolean ()" - publish :function => :Read, :type => "boolean ()" - publish :function => :Activate, :type => "boolean ()" - publish :function => :Write, :type => "boolean ()" - publish :function => :GetIOScheduler, :type => "string ()" - publish :function => :SetIOScheduler, :type => "void (string)" - publish :function => :GetSysRqKeysEnabled, :type => "boolean ()" - publish :function => :SetSysRqKeysEnabled, :type => "void (boolean)" + # Write IO Scheduler settings + # + # This method only has effect during normal mode. During installation, + # bootloader configuration is written at the end of the first stage. + # + # @see Bootloader#Write + # @see Write + def write_scheduler + Bootloader.Write if Mode.normal + true + end end SystemSettings = SystemSettingsClass.new diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/test/system_settings_test.rb new/yast2-tune-3.1.9/test/system_settings_test.rb --- old/yast2-tune-3.1.8/test/system_settings_test.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/yast2-tune-3.1.9/test/system_settings_test.rb 2016-07-14 09:51:43.000000000 +0200 @@ -0,0 +1,369 @@ +#!/usr/bin/env rspec + +require_relative "test_helper" + +Yast.import "SystemSettings" +Yast.import "Bootloader" + +describe "Yast::SystemSettings" do + KERNEL_SYSRQ_FILE = "/proc/sys/kernel/sysrq" + + subject(:settings) { Yast::SystemSettings } + + before do + allow(File).to receive(:exist?).and_return(true) + settings.main + end + + describe "#GetPossibleElevatorValues" do + it "returns an array with possible schedulers" do + expect(settings.GetPossibleElevatorValues).to match_array(["cfq", "noop", "deadline"]) + end + end + + describe "#Read" do + let(:kernel_sysrq) { "1" } + let(:sysctl_sysrq) { "1" } + let(:scheduler) { "cfq" } + + before do + allow(Yast::SCR).to receive(:Read).and_call_original + allow(Yast::SCR).to receive(:Read) + .with(Yast::Path.new(".etc.sysctl_conf.\"kernel.sysrq\"")) + .and_return(sysctl_sysrq) + allow(File).to receive(:read).with(KERNEL_SYSRQ_FILE) + .and_return(kernel_sysrq) + allow(Yast::Bootloader).to receive(:kernel_param) + .with(:common, "elevator").and_return(scheduler) + end + + context "when SysRq keys are enabled via sysctl" do + let(:sysctl_sysrq) { "1" } + + it "enables SysRq keys" do + settings.Read + expect(settings.GetSysRqKeysEnabled).to eq(true) + end + end + + context "when SysRq keys are disabled via sysctl" do + let(:sysctl_sysrq) { "0" } + + it "disables SysRq keys" do + settings.Read + expect(settings.GetSysRqKeysEnabled).to eq(false) + end + end + + context "when SysRq keys configuration cannot be read" do + let(:kernel_sysrq) { "0" } + let(:sysctl_sysrq) { nil } + + it "uses kernel value" do + settings.Read + expect(settings.GetSysRqKeysEnabled).to eq(false) + end + end + + context "when scheduler parameter is missing" do + let(:scheduler) { :missing } + + it "unsets IO scheduler" do + settings.Read + expect(settings.GetIOScheduler).to eq("") + end + end + + context "when scheduler parameter is present but does not have a value" do + let(:scheduler) { :present } + + it "unsets IO scheduler" do + settings.Read + expect(settings.GetIOScheduler).to eq("") + end + end + + context "when scheduler parameter has a valid value" do + it "sets IO scheduler to that value" do + settings.Read + expect(settings.GetIOScheduler).to eq(scheduler) + end + end + + context "when scheduler parameter has an invalid value" do + let(:scheduler) { "some-scheduler" } + + it "unsets IO scheduler" do + settings.Read + expect(settings.GetIOScheduler).to eq("") + end + end + + it "reads bootloader configuration" do + expect(Yast::Bootloader).to receive(:Read) + settings.Read + end + + context "is not in normal mode" do + before do + allow(Yast::Mode).to receive(:mode).and_return("installation") + end + + it "does not read bootloader configuration" do + expect(Yast::Bootloader).to_not receive(:Read) + settings.Read + end + + end + end + + describe "#Activate" do + let(:sysrq_keys) { false } + let(:scheduler) { "" } + let(:disk) { "/sys/block/sda/queue/scheduler" } + + before do + settings.SetSysRqKeysEnabled(sysrq_keys) + settings.SetIOScheduler(scheduler) + allow(Yast::Bootloader).to receive(:modify_kernel_params) + allow(Yast::Bootloader).to receive(:proposed_cfg_changed=) + allow(Dir).to receive(:[]).with(/scheduler/).and_return([disk]) + end + + context "when SysRq keys status is unknown" do + it "does not update /proc/sys/kernel/sysrq" do + settings.main + expect(File).to_not receive(:write).with(/sysrq/, anything) + settings.Activate + end + end + + context "when SysRq keys are enabled" do + let(:sysrq_keys) { true } + + it "writes '1' to /proc/sys/kernel/sysrq" do + expect(File).to receive(:write).with(KERNEL_SYSRQ_FILE, "1\n") + settings.Activate + end + end + + context "when SysRq keys is disabled" do + it "writes '0' to /proc/sys/kernel/sysrq" do + expect(::File).to receive(:write).with(KERNEL_SYSRQ_FILE, "0\n") + settings.Activate + end + end + + context "when a scheduler is set" do + let(:scheduler) { "cfq" } + + before do + allow(File).to receive(:write).with(KERNEL_SYSRQ_FILE, anything) + end + + it "updates bootloader configuration" do + expect(Yast::Bootloader).to receive(:modify_kernel_params) + .with("elevator" => scheduler) + expect(Yast::Bootloader).to receive(:proposed_cfg_changed=).with(true) + allow(File).to receive(:write) + settings.Activate + end + + it "activates scheduler for all disk devices" do + expect(File).to receive(:write).with(disk, scheduler) + settings.Activate + end + end + + context "when no scheduler is set" do + let(:scheduler) { "" } + + before do + allow(File).to receive(:write).with(KERNEL_SYSRQ_FILE, anything) + end + + it "removes parameter from bootloader configuration" do + expect(Yast::Bootloader).to receive(:modify_kernel_params) + .with("elevator" => :missing) + expect(Yast::Bootloader).to receive(:proposed_cfg_changed=).with(true) + settings.Activate + end + + it "does not activate scheduler" do + expect(File).to_not receive(:write).with(disk, anything) + settings.Activate + end + end + end + + describe "#Write" do + let(:sysctl_sysrq) { "0" } + let(:mode) { "normal" } + + before do + allow(Yast::Mode).to receive(:mode).and_return(mode) + allow(Yast::Bootloader).to receive(:Write) + allow(Yast::SCR).to receive(:Read).and_call_original + allow(Yast::SCR).to receive(:Read) + .with(Yast::Path.new(".etc.sysctl_conf.\"kernel.sysrq\"")) + .and_return(sysctl_sysrq) + end + + context "when system settings has been read" do + before { settings.Read } + + context "when SysRq keys status is valid" do + let(:sysctl_sysrq) { "0" } + + it "updates sysctl configuration" do + expect(Yast::SCR).to receive(:Write) + .with(Yast::Path.new(".etc.sysctl_conf.\"kernel.sysrq\""), sysctl_sysrq) + expect(Yast::SCR).to receive(:Write) + .with(Yast::Path.new(".etc.sysctl_conf"), nil) + settings.Write + end + end + + context "when SysRq keys status is not valid" do + let(:sysctl_sysrq) { "-1" } + + it "does not update sysctl configuration" do + expect(Yast::SCR).to_not receive(:Write) + .with(Yast::Path.new(".etc.sysctl_conf.\"kernel.sysrq\""), sysctl_sysrq) + settings.Write + end + end + end + + it "writes bootloader configuration" do + expect(Yast::Bootloader).to receive(:Write) + settings.Write + end + + context "is not in normal mode" do + let(:mode) { "installation" } + + it "does not write bootloader configuration" do + expect(Yast::Bootloader).to_not receive(:Write) + settings.Write + end + end + + context "when system settings hadn't been read" do + it "does not update sysctl configuration" do + expect(Yast::SCR).to_not receive(:Write) + .with(Yast::Path.new(".etc.sysctl_conf.\"kernel_sysrq\""), anything) + settings.Write + end + end + end + + describe "#SetIOScheduler" do + context "when scheduler is a known one" do + it "sets the scheduler to the given value" do + settings.SetIOScheduler("cfq") + expect(settings.GetIOScheduler).to eq("cfq") + end + end + + context "when scheduler is unknown" do + before do + settings.SetIOScheduler("cfq") + end + + it "does not modify the scheduler" do + settings.SetIOScheduler("some-scheduler") + expect(settings.GetIOScheduler).to eq("cfq") + end + end + + context "when new scheduler is different from previous one" do + before do + allow(Yast::Bootloader).to receive(:kernel_param) + .with(:common, "elevator").and_return("cfq") + settings.Read + end + + it "sets the module as modified" do + expect { settings.SetIOScheduler("noop") }.to change { settings.Modified } + .from(false).to(true) + end + end + end + + describe "#SetSysRqKeysEnabled" do + before do + allow(Yast::SCR).to receive(:Read).and_call_original + allow(Yast::SCR).to receive(:Read) + .with(Yast::Path.new(".etc.sysctl_conf.\"kernel.sysrq\"")) + .and_return(sysctl_sysrq) + settings.Read + end + + context "when SysRq is nil" do + let(:sysctl_sysrq) { "1" } + + it "does not modify SysRq keys configuration" do + expect { settings.SetSysRqKeysEnabled(nil) }.to_not change { settings.GetSysRqKeysEnabled } + end + + it "does not set the module as modified" do + expect { settings.SetSysRqKeysEnabled(nil) }.to_not change { settings.Modified } + end + end + + context "when SysRq keys are disabled" do + let(:sysctl_sysrq) { "0" } + + context "and 'false' is given" do + it "disables SysRq keys" do + settings.SetSysRqKeysEnabled(false) + expect(settings.GetSysRqKeysEnabled).to eq(false) + end + + it "does not set the module as modified" do + expect { settings.SetSysRqKeysEnabled(false) }.to_not change { settings.Modified } + end + end + + context "and 'true' is given" do + it "enables SysRq keys" do + settings.SetSysRqKeysEnabled(true) + expect(settings.GetSysRqKeysEnabled).to eq(true) + end + + it "sets the module as modified" do + expect { settings.SetSysRqKeysEnabled(true) }.to change { settings.Modified } + .from(false).to(true) + end + end + end + + context "when SysRq keys are enabled" do + let(:sysctl_sysrq) { "1" } + + context "and 'false' is given" do + it "disables SysRq keys" do + settings.SetSysRqKeysEnabled(false) + expect(settings.GetSysRqKeysEnabled).to eq(false) + end + + it "sets the module as modified" do + expect { settings.SetSysRqKeysEnabled(false) }.to change { settings.Modified } + .from(false).to(true) + end + end + + context "and 'true' is given" do + it "enables SysRq keys" do + settings.SetSysRqKeysEnabled(true) + expect(settings.GetSysRqKeysEnabled).to eq(true) + end + + it "does not set the module as modified" do + expect { settings.SetSysRqKeysEnabled(true) }.to_not change { settings.Modified } + end + end + end + end +end diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-tune-3.1.8/test/test_helper.rb new/yast2-tune-3.1.9/test/test_helper.rb --- old/yast2-tune-3.1.8/test/test_helper.rb 1970-01-01 01:00:00.000000000 +0100 +++ new/yast2-tune-3.1.9/test/test_helper.rb 2016-07-14 09:51:43.000000000 +0200 @@ -0,0 +1,23 @@ +ENV["Y2DIR"] = File.expand_path("../../src", __FILE__) + +require "yast" + +if ENV["COVERAGE"] + require "simplecov" + SimpleCov.start do + add_filter "/spec/" + end + + # for coverage we need to load all ruby files + src_location = File.expand_path("../../src", __FILE__) + Dir["#{src_location}/{modules,lib}/**/*.rb"].each { |f| require_relative f } + + # use coveralls for on-line code coverage reporting at Travis CI + if ENV["TRAVIS"] + require "coveralls" + SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[ + SimpleCov::Formatter::HTMLFormatter, + Coveralls::SimpleCov::Formatter + ] + end +end
