linux_admin 1.2.4 → 2.0.0

data/spec/service/sys_v_init_service_spec.rb

@@ -1,127 +0,0 @@
-describe LinuxAdmin::SysVInitService do
-  before do
-    @service = described_class.new 'foo'
-  end
-
-  describe "#running?" do
-    it "checks service" do
-      expect(LinuxAdmin::Common).to receive(:run)
-        .with(LinuxAdmin::Common.cmd(:service),
-              :params => {nil => %w(foo status)}).and_return(double(:exit_status => 0))
-      @service.running?
-    end
-
-    context "service is running" do
-      it "returns true" do
-        @service = described_class.new :id => :foo
-        expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
-        expect(@service).to be_running
-      end
-    end
-
-    context "service is not running" do
-      it "returns false" do
-        @service = described_class.new :id => :foo
-        expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
-        expect(@service).not_to be_running
-      end
-    end
-  end
-
-  describe "#enable" do
-    it "enables service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:chkconfig),
-              :params => {nil => %w(foo on)})
-      @service.enable
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!) # stub out cmd invocation
-      expect(@service.enable).to eq(@service)
-    end
-  end
-
-  describe "#disable" do
-    it "disable service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:chkconfig),
-              :params => {nil => %w(foo off)})
-      @service.disable
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-      expect(@service.disable).to eq(@service)
-    end
-  end
-
-  describe "#start" do
-    it "starts service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:service),
-              :params => {nil => %w(foo start)})
-      @service.start
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-      expect(@service.start).to eq(@service)
-    end
-  end
-
-  describe "#stop" do
-    it "stops service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:service),
-              :params => {nil => %w(foo stop)})
-      @service.stop
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-      expect(@service.stop).to eq(@service)
-    end
-  end
-
-  describe "#restart" do
-    it "stops service" do
-      expect(LinuxAdmin::Common).to receive(:run)
-        .with(LinuxAdmin::Common.cmd(:service),
-              :params => {nil => %w(foo restart)}).and_return(double(:exit_status => 0))
-      @service.restart
-    end
-
-    context "service restart fails" do
-      it "manually stops/starts service" do
-        expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
-        expect(@service).to receive(:stop)
-        expect(@service).to receive(:start)
-        @service.restart
-      end
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
-      expect(@service.restart).to eq(@service)
-    end
-  end
-
-  describe "#reload" do
-    it "reloads service" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(LinuxAdmin::Common.cmd(:service), :params => %w(foo reload))
-      expect(@service.reload).to eq(@service)
-    end
-  end
-
-  describe "#status" do
-    it "returns the service status" do
-      status = "service status here"
-      expect(LinuxAdmin::Common).to receive(:run)
-        .with(LinuxAdmin::Common.cmd(:service),
-              :params => %w(foo status)).and_return(double(:output => status))
-      expect(@service.status).to eq(status)
-    end
-  end
-end

data/spec/service/systemd_service_spec.rb

@@ -1,133 +0,0 @@
-describe LinuxAdmin::SystemdService do
-  let(:command) { LinuxAdmin::Common.cmd(:systemctl) }
-
-  before do
-    @service = described_class.new 'foo'
-  end
-
-  describe "#running?" do
-    it "checks service" do
-      expect(LinuxAdmin::Common).to receive(:run)
-        .with(command, :params => %w(status foo)).and_return(double(:success? => true))
-      @service.running?
-    end
-
-    it "returns true when service is running" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:success? => true))
-      expect(@service).to be_running
-    end
-
-    it "returns false when service is not running" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:success? => false))
-      expect(@service).not_to be_running
-    end
-  end
-
-  describe "#enable" do
-    it "enables service" do
-      expect(LinuxAdmin::Common).to receive(:run!) .with(command, :params => %w(enable foo))
-      @service.enable
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!) # stub out cmd invocation
-      expect(@service.enable).to eq(@service)
-    end
-  end
-
-  describe "#disable" do
-    it "disables service" do
-      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(disable foo))
-      @service.disable
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-      expect(@service.disable).to eq(@service)
-    end
-  end
-
-  describe "#start" do
-    it "starts service" do
-      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(start foo))
-      @service.start
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-      expect(@service.start).to eq(@service)
-    end
-  end
-
-  describe "#stop" do
-    it "stops service" do
-      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(stop foo))
-      @service.stop
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run!)
-      expect(@service.stop).to eq(@service)
-    end
-  end
-
-  describe "#restart" do
-    it "restarts service" do
-      expect(LinuxAdmin::Common).to receive(:run).with(command, :params => %w(restart foo)).and_return(double(:exit_status => 0))
-      @service.restart
-    end
-
-    it "manually stops then starts service when restart fails" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 1))
-      expect(@service).to receive(:stop)
-      expect(@service).to receive(:start)
-      @service.restart
-    end
-
-    it "returns self" do
-      expect(LinuxAdmin::Common).to receive(:run).and_return(double(:exit_status => 0))
-      expect(@service.restart).to eq(@service)
-    end
-  end
-
-  describe "#reload" do
-    it "reloads service" do
-      expect(LinuxAdmin::Common).to receive(:run!).with(command, :params => %w(reload foo))
-      expect(@service.reload).to eq(@service)
-    end
-  end
-
-  describe "#status" do
-    it "returns the service status" do
-      status = "service status here"
-      expect(LinuxAdmin::Common).to receive(:run)
-        .with(command, :params => %w(status foo)).and_return(double(:output => status))
-      expect(@service.status).to eq(status)
-    end
-  end
-
-  describe "#show" do
-    it "returns a hash of runtime information" do
-      output = <<-EOS
-MainPID=29189
-ExecMainStartTimestamp=Wed 2017-02-08 13:49:57 EST
-ExecStart={ path=/bin/sh ; argv[]=/bin/sh -c /bin/evmserver.sh start ; status=0/0 }
-ExecStop={ path=/bin/sh ; argv[]=/bin/sh -c /bin/evmserver.sh stop ; status=0/0 }
-ControlGroup=/system.slice/evmserverd.service
-MemoryCurrent=2865373184
-EOS
-
-      hash = {
-        "MainPID"                => 29_189,
-        "ExecMainStartTimestamp" => Time.new(2017, 2, 8, 13, 49, 57, "-05:00"),
-        "ExecStart"              => {"path" => "/bin/sh", "argv[]" => "/bin/sh -c /bin/evmserver.sh start", "status" => "0/0"},
-        "ExecStop"               => {"path" => "/bin/sh", "argv[]" => "/bin/sh -c /bin/evmserver.sh stop", "status" => "0/0"},
-        "ControlGroup"           => "/system.slice/evmserverd.service",
-        "MemoryCurrent"          => 2_865_373_184
-      }
-      expect(LinuxAdmin::Common).to receive(:run!)
-        .with(command, :params => %w(show foo)).and_return(double(:output => output))
-      expect(@service.show).to eq(hash)
-    end
-  end
-end

data/spec/service_spec.rb

@@ -1,54 +0,0 @@
-describe LinuxAdmin::Service do
-  context ".service_type" do
-    it "on systemctl systems" do
-      stub_to_service_type(:systemd_service)
-      expect(described_class.service_type).to eq(LinuxAdmin::SystemdService)
-    end
-
-    it "on sysv systems" do
-      stub_to_service_type(:sys_v_init_service)
-      expect(described_class.service_type).to eq(LinuxAdmin::SysVInitService)
-    end
-
-    it "should memoize results" do
-      expect(described_class).to receive(:service_type_uncached).once.and_return("anything_non_nil")
-      described_class.service_type
-      described_class.service_type
-    end
-
-    it "with reload should refresh results" do
-      expect(described_class).to receive(:service_type_uncached).twice.and_return("anything_non_nil")
-      described_class.service_type
-      described_class.service_type(true)
-    end
-  end
-
-  context ".new" do
-    it "on systemctl systems" do
-      stub_to_service_type(:systemd_service)
-      expect(described_class.new("xxx")).to be_kind_of(LinuxAdmin::SystemdService)
-    end
-
-    it "on sysv systems" do
-      stub_to_service_type(:sys_v_init_service)
-      expect(described_class.new("xxx")).to be_kind_of(LinuxAdmin::SysVInitService)
-    end
-  end
-
-  it "#id / #id=" do
-    s = described_class.new("xxx")
-    expect(s.id).to eq("xxx")
-
-    s.id = "yyy"
-    expect(s.id).to eq("yyy")
-    expect(s.name).to eq("yyy")
-
-    s.name = "zzz"
-    expect(s.id).to eq("zzz")
-    expect(s.name).to eq("zzz")
-  end
-
-  def stub_to_service_type(system)
-    allow(LinuxAdmin::Common).to receive(:cmd?).with(:systemctl).and_return(system == :systemd_service)
-  end
-end

data/spec/spec_helper.rb

@@ -1,116 +0,0 @@
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause this
-# file to always be loaded, without a need to explicitly require it in any files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, make a
-# separate helper file that requires this one and then use it only in the specs
-# that actually need it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-RSpec.configure do |config|
-# The settings below are suggested to provide a good initial experience
-# with RSpec, but feel free to customize to your heart's content.
-
-  # These two settings work together to allow you to limit a spec run
-  # to individual examples or groups you care about by tagging them with
-  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
-  # get run.
-  config.filter_run :focus
-  config.run_all_when_everything_filtered = true
-
-  # Many RSpec users commonly either run the entire suite or an individual
-  # file, and it's useful to allow more verbose output when running an
-  # individual spec file.
-  if config.files_to_run.one?
-    # Use the documentation formatter for detailed output,
-    # unless a formatter has already been configured
-    # (e.g. via a command-line flag).
-    config.default_formatter = 'doc'
-  end
-
-  # Print the 10 slowest examples and example groups at the
-  # end of the spec run, to help surface which specs are running
-  # particularly slow.
-  # config.profile_examples = 10
-
-  # Run specs in random order to surface order dependencies. If you find an
-  # order dependency and want to debug it, you can fix the order by providing
-  # the seed, which is printed after each run.
-  #     --seed 1234
-  config.order = :random
-
-  # Seed global randomization in this process using the `--seed` CLI option.
-  # Setting this allows you to use `--seed` to deterministically reproduce
-  # test failures related to randomization by passing the same `--seed` value
-  # as the one that triggered the failure.
-  Kernel.srand config.seed
-
-  # rspec-expectations config goes here. You can use an alternate
-  # assertion/expectation library such as wrong or the stdlib/minitest
-  # assertions if you prefer.
-  config.expect_with :rspec do |expectations|
-    # Enable only the newer, non-monkey-patching expect syntax.
-    # For more details, see:
-    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-    expectations.syntax = :expect
-  end
-
-  # rspec-mocks config goes here. You can use an alternate test double
-  # library (such as bogus or mocha) by changing the `mock_with` option here.
-  config.mock_with :rspec do |mocks|
-    # Enable only the newer, non-monkey-patching expect syntax.
-    # For more details, see:
-    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-    mocks.syntax = :expect
-
-    # Prevents you from mocking or stubbing a method that does not exist on
-    # a real object. This is generally recommended.
-    mocks.verify_partial_doubles = true
-  end
-
-  config.after do
-    clear_caches
-  end
-end
-
-begin
-  require 'coveralls'
-  Coveralls.wear!
-rescue LoadError
-end
-
-require 'linux_admin'
-
-def etc_issue_contains(contents)
-  LinuxAdmin::EtcIssue.instance.send(:refresh)
-  allow(File).to receive(:exist?).with('/etc/issue').at_least(:once).and_return(true)
-  allow(File).to receive(:read).with('/etc/issue').at_least(:once).and_return(contents)
-end
-
-def stub_distro(distro = LinuxAdmin::Distros.rhel)
-  # simply alias test distro to redhat distro for time being
-  allow(LinuxAdmin::Distros).to receive_messages(:local => distro)
-end
-
-def data_file_path(to)
-  File.expand_path(to, File.join(File.dirname(__FILE__), "data"))
-end
-
-def sample_output(to)
-  File.read(data_file_path(to))
-end
-
-def clear_caches
-  LinuxAdmin::RegistrationSystem.instance_variable_set(:@registration_type, nil)
-  LinuxAdmin::Service.instance_variable_set(:@service_type, nil)
-
-  # reset the distro, tested in various placed & used extensively
-  LinuxAdmin::Distros.instance_variable_set(:@local, nil)
-end

data/spec/ssh_spec.rb

@@ -1,53 +0,0 @@
-describe LinuxAdmin::SSH do
-  before(:each) do
-    require 'net/ssh'
-    @example_ssh_key = <<-eos
------BEGIN RSA PRIVATE KEY-----
-MIIEowIBAAKCAQEAasdvkMNteq7hjnqNE61ESnEHnaOtHxZffdsQ33R7BXcu9eCH
-ncZadHmmfRZgMPQnHGX0NzboVKfdpdF40o+iGQKyy3wKqdgGnTAWqx/hxrsdsdgh
-f/g7AABNjoWp1OiTX2Dn99SH9xPQtpdnwGlBmtPplV2wNcKouQwGbwb/u1EHHxnO
-aSQk2tvKHRMgroLsyuM5ay7TrK5cip2QTMn9fieHIepH0qd8ETG+1Uf+XmZxhdMN
-QsuiSbAAmuU9qwlXh6QOg1spJ97B/ZY6Ci4d5cdBCCtfjGDBm8CzbrfhYVNhGcNx
-c3Y43ld6MJoE+hMuBrBSuZyBmf63AAMqJ8KeQwIDAQABAoIBAFMFXBoSWOy1V9z3
-IkoY1ilBp5WKRvaPEMCgeCfZIjIG0Nmt5Knbkp2b3A8YWnGQlDHqdYz53t9RHaaU
-KdCnJ9vUSYeeeNElMsCwMYVoZvA5Xpv9cw2YOeTrOzssX1VZv9WW1zHd0Srz9N3r
-719MgpyK4dZACw6ODeD/gh8+OH5OAN9sVbIGniApHZENxJrZzL22qE2asf8vVfgu
-9XNx3WhsdL6ktoeJWLKxTLwVP6xRK/ixvsayUFeMBC4E1+sBuz1z7p27kd8cEC5o
-AEHSwF6nr+ix0JctbAYqPVFZi5zFH10WgxyF3asAiQPYrCrY9gT8OQSRDhhKyIXE
-rHlLIfkCgYEA+RuY4vsqeU69APFXRCy9s/dcy8tS0Pslq/fq4KsdC4qRu39RjotN
-/OXOtVMPRfjTiRHXi/0fvSfyMVgstCtfYpOcoz98tw2AX34AgAH6h57I29rVxk5q
-OomgcauRYlmO9ge3429pvECL5EzBbRKwfwuMKHMNetLHdVMc7d165f0CgYEAzdGf
-6VMnZkK66XP/RzMvwUwvdhy+vIUjXFMjotQXYcYcLZadiZET7riOSRyVRvlNg0va
-CexWtX+0yOZOrXCvLzSpO8Z91VnkHbRhnpy4bvW/qcFpwIvYeaMgr5C1lBHCIvZS
-wSojNrdjAbdQoqab9X7Mxj2ubYGxUSSg715wqT8CgYBaY20iT0imI6/o+6lSj3l2
-J7eAKxKtybNtptOPF6RVq74dbqFFO77cmPZcTPspxJPdFKBFp18w36G9zeTKq0I9
-HpqjkZHLShbej3XW/ODO/Qqc29bd0e4xt2aEWGC0cxKwqzRKTk7rg/A+sqsszK9G
-KgZ9VuH5QyokpDfHB6pkcQKBgChsq8PgGTT0llGT/ue1HgQROqEwNCZC4BcaHT21
-+oGxr4cktfx3Cjsw9IFXo9o0zQyksUaRrNYpJxDuazWVlFLpPPQIoF5vMWbELwhA
-L9lbWzG0U1kGHpaFe73/5ioW8tJ7HvXhmNj+W+vSXXwUzT0CkqW9J61Kc9FEKHfb
-TLVxAoGBAM8WKsTfEMxuv5pabGTo8BC1ruz4c5qLJGLGnH4kWJm5o6ippugFsOlK
-rDUWive4uLSKi3Fsb2kPw6gHuRGerFN1CBpCENLib3xG5Bd4XhmKZMDxqU2bO0gd
-sV1Tr/acrE0aWBkD9RYrR2/UwG1zfXuIJeufdWf8c0SY3X6J7jJN
------END RSA PRIVATE KEY-----
-    eos
-  end
-
-  it "should create a call using agent" do
-    expect(Net::SSH).to receive(:start).with("127.0.0.1", "root", :verify_host_key => false, :forward_agent => true, :number_of_password_prompts => 0, :agent_socket_factory => Proc).and_return(true)
-    ssh_agent = LinuxAdmin::SSHAgent.new(@example_ssh_key)
-    ssh_agent.with_service do |socket|
-      ssh = LinuxAdmin::SSH.new("127.0.0.1", "root")
-      ssh.perform_commands(%w("ls", "pwd"), socket)
-    end
-  end
-
-  it "should preform command using private key" do
-    expect(Net::SSH).to receive(:start).with("127.0.0.1", "root", :verify_host_key => false, :number_of_password_prompts => 0, :key_data => [@example_ssh_key]).and_return(true)
-    LinuxAdmin::SSH.new("127.0.0.1", "root", @example_ssh_key).perform_commands(%w("ls", "pwd"))
-  end
-
-  it "should preform command using password" do
-    expect(Net::SSH).to receive(:start).with("127.0.0.1", "root", :verify_host_key => false, :number_of_password_prompts => 0, :password => "password").and_return(true)
-    LinuxAdmin::SSH.new("127.0.0.1", "root", nil, "password").perform_commands(%w("ls", "pwd"))
-  end
-end