inspec 0.30.0 → 0.31.0

data/test/unit/resources/xinetd_test.rb

@@ -1,60 +0,0 @@
-# encoding: utf-8
-# author: Christoph Hartmann
-# author: Dominik Richter
-
-require 'helper'
-require 'inspec/resource'
-
-describe 'Inspec::Resources::XinetdConf' do
-  let(:resource) { load_resource('xinetd_conf') }
-  it 'reads default params' do
-    d = resource.params['defaults']
-    _(d).must_be_kind_of SimpleConfig
-    _(d.params['instances']).must_equal '50'
-    _(d.params['log_type']).must_equal 'SYSLOG daemon info'
-    _(d.params.length).must_equal 2
-  end
-
-  describe 'with services from child configs' do
-    it 'has one service name' do
-      _(resource.services.uniq).must_equal %w{chargen}
-    end
-
-    it 'has multiple service definitions' do
-      _(resource.ids).must_equal %w{chargen-stream chargen-dgram}
-    end
-
-    it 'can filter by name' do
-      _(resource.services('not here').services).must_be_empty
-    end
-
-    it 'can chain filters' do
-      one = resource.services('chargen').socket_types('dgram')
-      _(one.services.length).must_equal 1
-      _(one.ids).must_equal %w{chargen-dgram}
-    end
-
-    it 'checks if all are disabled on one disabled service' do
-      one = resource.ids('chargen-stream')
-      _(one.disabled?).must_equal true
-    end
-
-    it 'checks if all are disabled on multiple mixed' do
-      _(resource.disabled?).must_equal false
-    end
-
-    it 'checks if all are enabled on one enabled service' do
-      one = resource.ids(/dgram$/)
-      _(one.enabled?).must_equal true
-    end
-
-    it 'checks if all are enabled on one enabled service' do
-      one = resource.ids(/stream$/)
-      _(one.enabled?).must_equal false
-    end
-
-    it 'checks if all are enabled on multiple mixed' do
-      _(resource.enabled?).must_equal false
-    end
-  end
-end

data/test/unit/resources/yaml_test.rb

@@ -1,34 +0,0 @@
-# encoding: utf-8
-
-require 'helper'
-require 'inspec/resource'
-
-describe 'Inspec::Resources::YAML' do
-  describe 'when loading a valid yaml' do
-    let (:resource) { load_resource('yaml', 'kitchen.yml') }
-
-    it 'gets params as a hashmap' do
-      _(resource.params).must_be_kind_of Hash
-    end
-
-    it 'retrieves nil if a param is missing' do
-      _(resource.params['missing']).must_be_nil
-    end
-
-    it 'retrieves params by name' do
-      _(resource.send('name')).must_equal 'vagrant'
-    end
-
-    it 'retrieves an array by name' do
-      _(resource.send('platforms')).must_equal %w{linux mac}
-    end
-
-    it 'doesnt resolve dot-notation names' do
-      _(resource.send('driver.customize.memory')).must_be_nil
-    end
-
-    it 'doesnt resolve symbol-notation names' do
-      _(resource.send(:'driver.customize.memory')).must_be_nil
-    end
-  end
-end

data/test/unit/resources/yum_test.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-# author: Christoph Hartmann
-# author: Dominik Richter
-
-require 'helper'
-require 'inspec/resource'
-
-describe 'Inspec::Resources::YumRepo' do
-  it 'get repository details' do
-    resource = MockLoader.new(:centos7).load_resource('yum')
-    _(resource.repositories).must_equal [{
-      'id'=>'base/7/x86_64',
-      'name'=>'CentOS-7 - Base',
-      'status'=>'enabled',
-      'revision'=>'1427842153',
-      'updated'=>'Tue Mar 31 22:50:46 2015',
-      'pkgs'=>'8652',
-      'size'=>'6.3 G',
-      'mirrors'=>'http://mirrorlist.centos.org/?release=7&arch=x86_64&repo=os&infra=stock',
-      'baseurl'=>'http://ftp.hosteurope.de/mirror/centos.org/7.1.1503/os/x86_64/ (9 more)',
-      'expire'=>'21600 second(s) (last: Sun Sep  6 10:20:46 2015)',
-      'filename'=>'/etc/yum.repos.d/CentOS-Base.repo',
-    }, {
-      'id'=>'base-debuginfo/x86_64',
-      'name'=>'CentOS-7 - Debuginfo',
-      'status'=>'disabled',
-      'baseurl'=>'http://debuginfo.centos.org/7/x86_64/',
-      'expire'=>'21600 second(s) (last: Unknown)',
-      'filename'=>'/etc/yum.repos.d/CentOS-Debuginfo.repo',
-    }, {
-      'id'=>'extras/7/x86_64',
-      'name'=>'CentOS-7 - Extras',
-      'status'=>'enabled',
-      'revision'=>'1441314199',
-      'updated'=>'Thu Sep  3 21:03:33 2015',
-      'pkgs'=>'181',
-      'size'=>'742 M',
-      'mirrors'=>'http://mirrorlist.centos.org/?release=7&arch=x86_64&repo=extras&infra=stock',
-      'baseurl'=>'http://mirror.informatik.hs-fulda.de/centos7.1.1503/extras/x86_64/ (9 more)',
-      'expire'=>'21600 second(s) (last: Sun Sep  6 10:20:48 2015)',
-      'filename'=>'/etc/yum.repos.d/CentOS-Base.repo',
-    }]
-    _(resource.repos.length).must_equal 3
-    # get repository details
-    _(resource.repos).must_equal %w{base/7/x86_64 base-debuginfo/x86_64 extras/7/x86_64}
-    # test its syntax repo
-    _(resource.extras.exist?).must_equal true
-    _(resource.extras.enabled?).must_equal true
-    # test enabled extra repo
-    extras = resource.repo('extras/7/x86_64')
-    _(extras.exist?).must_equal true
-    _(extras.enabled?).must_equal true
-    # test enabled extra repo with short name
-    extras = resource.repo('extras')
-    _(extras.exist?).must_equal true
-    _(extras.enabled?).must_equal true
-    # test disabled extra-source repo
-    extras = resource.repo('base-debuginfo/x86_64')
-    _(extras.exist?).must_equal true
-    _(extras.enabled?).must_equal false
-  end
-
-  it 'test enabled extra repo (serverspec backwards comptability)' do
-    serverspec = load_resource('yumrepo', 'extras')
-    _(serverspec.exists?).must_equal true
-    _(serverspec.enabled?).must_equal true
-  end
-end

data/test/unit/shell_detector_test.rb

@@ -1,78 +0,0 @@
-# encoding: utf-8
-# author: Steven Danna <steve@chef.io>
-#
-require 'helper'
-require 'rbconfig'
-require 'mocha/test_unit'
-require 'inspec/shell_detector'
-
-module ShellDetectorTestHelpers
-  def no_proc
-    Dir.expects(:exist?).with('/proc').returns(false)
-  end
-
-  def with_proc(shell)
-    Dir.expects(:exist?).with('/proc').returns(true)
-    File.expects(:readlink).with("/proc/#{ppid}/exe").returns(shell)
-  end
-
-  def with_ps(output)
-    subject.expects(:'`').with("ps -cp #{ppid} -o command=").returns(output)
-  end
-
-  def with_env(shell)
-    ENV.expects(:[]).with('SHELL').returns(shell)
-  end
-
-  def with_pwuid(shell)
-    Process.expects(:uid).returns(9999)
-    @mock_user = Minitest::Mock.new
-    @mock_user.expect :shell, shell
-    Etc.expects(:getpwuid).with(9999).returns(@mock_user)
-  end
-end
-
-describe Inspec::ShellDetector do
-  include ShellDetectorTestHelpers
-
-  let(:subject) { Inspec::ShellDetector.new }
-  let(:ppid) { Process.ppid }
-
-  # Small hack to ensure we can test on windows
-  it "returns nil immediately if running on windows" do
-    RbConfig::CONFIG.expects(:[]).with('host_os').returns('mswin')
-    subject.shell!.must_equal(nil)
-  end
-
-  describe "not on windows" do
-    before do
-      RbConfig::CONFIG.expects(:[]).with('host_os').returns('beos')
-    end
-
-    it "detects the shell via /proc if it exists" do
-      with_proc("/usr/bin/fish")
-      subject.shell!.must_equal("fish")
-    end
-
-    it "detects via `ps` if /proc doesn't exist" do
-      no_proc; with_ps("/usr/bin/ksh")
-      subject.shell!.must_equal("ksh")
-    end
-
-    it "detects via ENV if parent process methods failed" do
-      no_proc; with_ps(""); with_env("fish")
-      subject.shell!.must_equal("fish")
-    end
-
-    it "detects via getpwuid if all else fails" do
-      no_proc; with_ps(""); with_env(""); with_pwuid("/usr/bin/fish")
-      subject.shell!.must_equal("fish")
-      @mock_user.verify
-    end
-
-    it "returns nil if the shell isn't in the whitelist" do
-      no_proc; with_ps(""); with_env("badshell"); with_pwuid("/usr/bin/badshell")
-      subject.shell!.must_equal(nil)
-    end
-  end
-end

data/test/unit/source_reader_test.rb

@@ -1,17 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'helper'
-
-describe Inspec::SourceReader do
-  let(:reg) { Inspec::SourceReader }
-
-  it 'resolves nil-targets to nil' do
-    _(reg.resolve(nil)).must_be_nil
-  end
-
-  it 'only supports Fetchers' do
-    proc { reg.resolve("not supported") }.must_raise StandardError
-  end
-end

data/test/unit/source_readers/flat_test.rb

@@ -1,61 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'helper'
-
-describe SourceReaders::Flat do
-  let(:reader) { SourceReaders::Flat }
-
-  it 'registers with the source readers registry' do
-    reg = Inspec::SourceReader.registry
-    _(reg['flat']).must_equal reader
-  end
-
-  describe 'with a flat file' do
-    let(:target) { Inspec::Fetcher.resolve(__FILE__) }
-    let(:res) { Inspec::SourceReader.resolve(target.relative_target) }
-
-    it 'resolves the target' do
-      _(res).must_be_kind_of reader
-    end
-
-    it 'has no metadata' do
-      _(res.metadata.params).must_equal({})
-    end
-
-    it 'retrieves all files' do
-      _(res.tests.keys).must_equal [File.basename(__FILE__)]
-      _(res.tests.values[0]).must_equal File.read(__FILE__)
-    end
-
-    it 'has no libraries' do
-      _(res.libraries).must_be_empty
-    end
-  end
-
-  describe 'with a flat folder' do
-    let(:target) { Inspec::Fetcher.resolve(File.dirname(__FILE__)) }
-    let(:res) { Inspec::SourceReader.resolve(target.relative_target) }
-
-    it 'resolves the target' do
-      _(res).must_be_kind_of reader
-    end
-
-    it 'has no metadata' do
-      _(res.metadata.params).must_equal({})
-    end
-
-    it 'retrieves all files' do
-      dir = File.dirname(__FILE__)
-      full_files = Dir[File.join(dir, '**')]
-      files = full_files.map { |x| x.sub(dir+'/', '') }
-      _(res.tests.keys).must_equal files
-      _(res.tests.values[0]).must_equal File.read(full_files[0])
-    end
-
-    it 'has no libraries' do
-      _(res.libraries).must_be_empty
-    end
-  end
-end

data/test/unit/source_readers/inspec_test.rb

@@ -1,38 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'helper'
-
-describe SourceReaders::InspecReader do
-  let(:reader) { SourceReaders::InspecReader }
-
-  it 'registers with the source readers registry' do
-    reg = Inspec::SourceReader.registry
-    _(reg['inspec']).must_equal reader
-  end
-
-  describe 'with a valid profile' do
-    let(:mock_file) { mock_file = MockLoader.profile_tgz('complete-profile') }
-    let(:target) { Inspec::Fetcher.resolve(mock_file) }
-    let(:res) { Inspec::SourceReader.resolve(target) }
-
-    it 'resolves the target to inspec' do
-      _(res).must_be_kind_of reader
-    end
-
-    it 'retrieves metadata' do
-      _(res.metadata.params[:name]).must_equal 'complete'
-    end
-
-    it 'retrieves all files' do
-      _(res.tests.keys).must_equal %w{controls/filesystem_spec.rb}
-      _(res.tests.values[0]).must_match /^control 'test01' do$/
-    end
-
-    it 'retrieves all libraries' do
-      _(res.libraries.keys).must_equal %w{libraries/testlib.rb}
-      _(res.libraries.values[0]).must_match /^# Library resource$/
-    end
-  end
-end

data/test/unit/utils/filter_array_test.rb

@@ -1,59 +0,0 @@
-# author: Stephan Renatus
-
-require 'helper'
-
-describe FilterArray do
-  let (:data) {[
-    { foo: 3, bar: true, baz: 'yay' },
-    { foo: 2, bar: false, baz: 'noo' },
-    { foo: 2, bar: false, baz: 'whatever' },
-  ]}
-
-  let (:instance) do
-    FilterArray.new data
-  end
-
-  describe '#content' do
-    it 'returns the current set' do
-      instance.content.must_equal data
-    end
-
-    it 'can also be referred to as #rules' do
-      instance.rules.must_equal instance.content
-    end
-  end
-
-  describe '#field' do
-    it 'retrieves (unique) values' do
-      instance.field('foo').must_equal [3, 2]
-    end
-
-    it 'filters the current set' do
-      instance.field('foo', 2).content.must_equal [
-        { foo: 2, bar: false, baz: 'noo' },
-        { foo: 2, bar: false, baz: 'whatever' },
-      ]
-    end
-
-    it 'can be chained' do
-      instance.field('foo', 2).field('baz', 'noo').content.must_equal [
-        { foo: 2, bar: false, baz: 'noo' },
-      ]
-    end
-
-    it 'can be abbreviated for retrieval' do
-      instance.foo.must_equal [3, 2]
-    end
-
-    it 'can be abbreviated for querying' do
-      instance.foo(2).content.must_equal [
-        { foo: 2, bar: false, baz: 'noo' },
-        { foo: 2, bar: false, baz: 'whatever' },
-      ]
-    end
-
-    it 'returns `[nil]` when queried for a non-existing key' do
-      instance.what.must_equal [nil]
-    end
-  end
-end

data/test/unit/utils/filter_table_test.rb

@@ -1,177 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Stephan Renatus
-# author: Christoph Hartmann
-
-require 'helper'
-
-describe FilterTable do
-  let (:data) {[
-    { foo: 3, bar: true, baz: 'yay', num: nil, snum: "0" },
-    { foo: 2, bar: false, baz: 'noo', num: 1, snum: nil },
-    { foo: 2, bar: false, baz: 'whatever', num: 2, snum: "1.00" },
-  ]}
-
-  let (:resource) {
-    Class.new do
-      attr_reader :data
-      def initialize(data)
-        @data = data
-      end
-    end
-  }
-
-  let (:factory) { FilterTable.create }
-  let (:instance) { resource.new(data) }
-
-  it 'has a create utility which creates a filter factory' do
-    factory.must_be_kind_of FilterTable::Factory
-  end
-
-  it 'retrieves the resource from all entries' do
-    factory.add_accessor(:where)
-           .add(:baz?) { |x| x.resource }
-           .connect(resource, :data)
-    instance.baz?.must_equal instance
-  end
-
-  describe 'when calling add_accessor' do
-    it 'is chainable' do
-      factory.add_accessor(:sth).must_equal factory
-    end
-
-    it 'wont add nil' do
-      proc { factory.add_accessor(nil) }.must_throw RuntimeError
-    end
-
-    it 'can expose the where method' do
-      factory.add_accessor(:where).connect(resource, :data)
-      _(instance.respond_to?(:where)).must_equal true
-      instance.where({ baz: 'yay' }).params.must_equal [data[0]]
-    end
-
-    it 'will delegate even non-existing methods' do
-      factory.add_accessor(:not_here).connect(resource, :data)
-      _(instance.respond_to?(:not_here)).must_equal true
-    end
-  end
-
-  describe 'when calling add' do
-    it 'is chainable' do
-      factory.add(:sth).must_equal factory
-    end
-
-    it 'wont add nil' do
-      proc { factory.add(nil) }.must_throw RuntimeError
-    end
-
-    it 'can expose a data column' do
-      factory.add(:baz).connect(resource, :data)
-      instance.baz(123).must_be_kind_of(FilterTable::Table)
-    end
-
-    it 'retrieves all entries' do
-      factory.add(:foo).connect(resource, :data)
-      instance.foo.must_equal([3, 2, 2])
-    end
-
-    it 'retrieves entries with simple style' do
-      factory.add(:foo, style: :simple)
-             .add(:num, style: :simple)
-             .connect(resource, :data)
-      instance.foo.must_equal([3, 2])
-      instance.num.must_equal([1, 2])
-    end
-  end
-
-  describe 'when calling entries' do
-    before { factory.add(:baz).connect(resource, :data) }
-    let(:entries) { instance.baz(/.*/).entries }
-    let(:entry) { instance.baz('yay').entries }
-
-    it 'retrieves all entries with this field' do
-      entries.length.must_equal 3
-      entry.length.must_equal 1
-    end
-
-    it 'retrieves all entries with this field' do
-      entry[0].must_be_kind_of(Struct)
-    end
-
-    it 'retrieves all entries with this field' do
-      entry[0].baz.must_equal 'yay'
-    end
-
-    it 'prints nicely' do
-      entry[0].to_s.must_match(/ with baz == "yay" one entry/)
-    end
-  end
-
-  describe 'with the number field' do
-    before { factory.add(:num).connect(resource, :data) }
-
-    it 'filter by nil' do
-      instance.num(nil).params.must_equal [data[0]]
-    end
-
-    it 'filter by existing numbers' do
-      instance.num(1).params.must_equal [data[1]]
-    end
-
-    it 'filter by missing number' do
-      instance.num(-1).params.must_equal []
-    end
-  end
-
-  describe 'with the string-number field' do
-    before { factory.add(:snum).connect(resource, :data) }
-
-    it 'retrieves the number 0' do
-      instance.snum(0).params.must_equal [data[0]]
-    end
-
-    it 'retrieves the number 1' do
-      instance.snum(1).params.must_equal []
-    end
-  end
-
-  describe 'with the string-float field' do
-    before { factory.add(:snum).connect(resource, :data) }
-
-    it 'retrieves the float 0.0' do
-      instance.snum(0.0).params.must_equal [data[0]]
-    end
-
-    it 'retrieves the float 1.0' do
-      instance.snum(1.0).params.must_equal [data[2]]
-    end
-  end
-
-  describe 'with a regex check' do
-    before { factory.add(:baz).connect(resource, :data) }
-
-    it 'retrieves the number 0' do
-      instance.baz(/ever$/).params.must_equal [data[2]]
-    end
-  end
-
-  describe 'with the string field' do
-    before { factory.add(:baz).connect(resource, :data) }
-
-    it 'filter by existing strings' do
-      instance.baz('yay').params.must_equal [data[0]]
-    end
-
-    it 'filter by missing string' do
-      instance.baz('num').params.must_equal []
-    end
-
-    it 'filter by existing regex' do
-      instance.baz(/A/i).params.must_equal [data[0], data[2]]
-    end
-
-    it 'filter by missing regex' do
-      instance.baz(/zzz/).params.must_equal []
-    end
-  end
-end

data/test/unit/utils/find_files_test.rb

@@ -1,23 +0,0 @@
-# encoding: utf-8
-# author: Stephan Renatus
-
-require 'helper'
-
-describe FindFiles do
-  let (:findfiles) do
-    class FindFilesTest
-      include FindFiles
-      def inspec
-        Inspec::Backend.create(backend: :mock)
-      end
-    end
-    FindFilesTest.new
-  end
-
-  describe '#find_files' do
-    it 'returns an array (of findings)' do
-      files = findfiles.find_files('/no/such/mock', type: 'file', depth: 1)
-      files.must_equal([])
-    end
-  end
-end

data/test/unit/utils/passwd_parser_test.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-# author: Dominik Richter
-# author: Christoph Hartmann
-
-require 'helper'
-
-describe PasswdParser do
-  let (:parser) { Class.new() { include PasswdParser }.new }
-
-  describe '#parse_passwd' do
-    it 'parses nil content' do
-      parser.parse_passwd(nil).must_equal([])
-    end
-
-    it 'parses an empty passwd line' do
-      parser.parse_passwd('').must_equal([])
-    end
-
-    it 'parses a valid passwd line' do
-      info = [{
-        "user"=>"root",
-        "password"=>"x",
-        "uid"=>"0",
-        "gid"=>"0",
-        "desc"=>"root",
-        "home"=>"/root",
-        "shell"=>"/bin/sh"
-      }]
-      parser.parse_passwd('root:x:0:0:root:/root:/bin/sh').must_equal(info)
-    end
-  end
-end