onceover 3.0.0

data/lib/onceover/group.rb

@@ -0,0 +1,85 @@
+require 'onceover/class'
+require 'onceover/node'
+
+class Onceover
+  class Group
+    @@all = []
+
+    # Work out how to do class veriables so that I can keep track of all the groups easily
+    attr_accessor :name
+    attr_accessor :members
+
+    # You need to pass in an array of strings for members, not objects, it will find the objects
+    # by itself, and yes it will reference them, not just create additional ones, woo!
+
+    def initialize(name = nil, members = [])
+      @name = name
+      @members = []
+
+      if Onceover::Group.valid_members?(members)
+        # If it's already a valid list just chuck it in there
+        @members = members
+      elsif members.is_a?(Hash)
+        # if it's a hash then do subtractive stiff
+        @members = Onceover::Group.subtractive_to_list(members)
+      else
+        # Turn it into a full list
+        member_objects = []
+
+        # This should also handle lists that include groups
+        members.each { |member| member_objects << Onceover::TestConfig.find_list(member) }
+        member_objects.flatten!
+
+        # Check that they are all the same type
+        unless Onceover::Group.valid_members?(member_objects)
+          raise 'Groups must contain either all nodes or all classes. Either there was a mix, or something was spelled wrong'
+        end
+
+        # Smash it into the instance variable
+        @members = member_objects
+      end
+
+      # Finally add it to the list of all grops
+      @@all << self
+    end
+
+    def self.find(group_name)
+      @@all.each do |group|
+        if group.name == group_name
+          return group
+        end
+      end
+      nil
+    end
+
+    def self.all
+      @@all
+    end
+
+    def self.valid_members?(members)
+      # Check that they are all the same type
+      # Also catch any errors to assume it's invalid
+      begin
+        if members.all? { |item| item.is_a?(Onceover::Class) }
+          return true
+        elsif members.all? { |item| item.is_a?(Onceover::Node) }
+          return true
+        else
+          return false
+        end
+      rescue
+        return false
+      end
+    end
+
+    def self.subtractive_to_list(subtractive_hash)
+      # Take a hash that looks like this:
+      # { 'include' => 'somegroup'
+      #   'exclude' => 'other'}
+      # and return a list of classes/nodes
+      include_list = Onceover::TestConfig.find_list(subtractive_hash['include'])
+      exclude_list = Onceover::TestConfig.find_list(subtractive_hash['exclude'])
+      include_list - exclude_list
+    end
+  end
+end

data/lib/onceover/logger.rb

@@ -0,0 +1,31 @@
+require 'logging'
+
+module Onceover::Logger
+  def logger
+    unless $logger
+      # here we setup a color scheme called 'bright'
+      Logging.color_scheme( 'bright',
+        :levels => {
+          :debug => :cyan,
+          :info  => :green,
+          :warn  => :yellow,
+          :error => :red,
+          :fatal => [:white, :on_red]
+        }
+      )
+
+      Logging.appenders.stdout(
+        'stdout',
+        :layout => Logging.layouts.pattern(
+          :pattern => '%l\t -> %m\n',
+          :color_scheme => 'bright'
+        )
+      )
+
+      $logger = Logging.logger['Colors']
+      $logger.add_appenders 'stdout'
+      $logger.level = :warn
+    end
+    $logger
+  end
+end

data/lib/onceover/node.rb

@@ -0,0 +1,44 @@
+require 'onceover/controlrepo'
+
+class Onceover
+  class Node
+    @@all = []
+
+
+    attr_accessor :name
+    attr_accessor :beaker_node
+    attr_accessor :fact_set
+
+    def initialize(name)
+      @name = name
+      @beaker_node = nil
+
+      # If we can't find the factset it will fail, so just catch that error and ignore it
+      begin
+        @fact_set = Onceover::Controlrepo.facts[Onceover::Controlrepo.facts_files.index{|facts_file| File.basename(facts_file,'.json') == name}]
+      rescue TypeError
+        @fact_set = nil
+      end
+      @@all << self
+
+    end
+
+    def self.find(node_name)
+      @@all.each do |node|
+        if node_name.is_a?(Onceover::Node)
+          if node = node_name
+            return node
+          end
+        elsif node.name == node_name
+          return node
+        end
+      end
+      logger.warn "Node #{node_name} not found"
+      nil
+    end
+
+    def self.all
+      @@all
+    end
+  end
+end

data/lib/onceover/rake_tasks.rb

@@ -0,0 +1,113 @@
+require 'onceover/controlrepo'
+require 'pathname'
+
+@repo = nil
+@config = nil
+
+task :generate_fixtures do
+  repo = Onceover::Controlrepo.new
+  raise ".fixtures.yml already exits, we won't overwrite because we are scared" if File.exists?(File.expand_path('./.fixtures.yml',repo.root))
+  File.write(File.expand_path('./.fixtures.yml',repo.root),repo.fixtures)
+end
+
+task :hiera_setup do
+  repo = Onceover::Controlrepo.new
+  current_config = repo.hiera_config
+  current_config.each do |key, value|
+    if value.is_a?(Hash)
+      if value.has_key?(:datadir)
+        current_config[key][:datadir] = Pathname.new(repo.hiera_data).relative_path_from(Pathname.new(File.expand_path('..',repo.hiera_config_file))).to_s
+      end
+    end
+  end
+  puts "Changing hiera config from \n#{repo.hiera_config}\nto\n#{current_config}"
+  repo.hiera_config = current_config
+end
+
+task :controlrepo_details do
+  require 'onceover/controlrepo'
+  puts Onceover::Controlrepo.new.to_s
+end
+
+task :generate_controlrepo_yaml do
+  require 'onceover/controlrepo'
+  repo = Onceover::Controlrepo.new
+  template_dir = File.expand_path('../../templates',File.dirname(__FILE__))
+  controlrepo_yaml_template = File.read(File.expand_path('./controlrepo.yaml.erb',template_dir))
+  puts ERB.new(controlrepo_yaml_template, nil, '-').result(binding)
+end
+
+
+task :generate_nodesets do
+  require 'onceover/beaker'
+  require 'net/http'
+  require 'json'
+
+  repo = Onceover::Controlrepo.new
+
+  puts "HOSTS:"
+
+  repo.facts.each do |fact_set|
+    node_name = File.basename(repo.facts_files[repo.facts.index(fact_set)],'.json')
+    boxname = Onceover::Beaker.facts_to_vagrant_box(fact_set)
+    platform = Onceover::Beaker.facts_to_platform(fact_set)
+    response = Net::HTTP.get(URI.parse("https://atlas.hashicorp.com/api/v1/box/#{boxname}"))
+    url = 'URL goes here'
+
+    if response =~ /Not Found/i
+      comment_out = true
+    else
+      comment_out = false
+      box_info = JSON.parse(response)
+      box_info['current_version']['providers'].each do |provider|
+        if  provider['name'] == 'virtualbox'
+          url = provider['original_url']
+        end
+      end
+    end
+
+    # Use an ERB template
+    template_dir = File.expand_path('../../templates',File.dirname(__FILE__))
+    fixtures_template = File.read(File.expand_path('./nodeset.yaml.erb',template_dir))
+    puts ERB.new(fixtures_template, nil, '-').result(binding)
+  end
+
+end
+
+task :controlrepo_autotest_prep do
+  require 'onceover/testconfig'
+  require 'onceover/runner'
+  @repo = Onceover::Controlrepo.new
+  # TODO: This should be getting the location of controlrepo.yaml from @repo
+  @config = Onceover::TestConfig.new("#{@repo.spec_dir}/controlrepo.yaml")
+
+  @runner = Onceover::Runner.new(@repo, @config)
+  @runner.prepare!
+end
+
+task :controlrepo_autotest_spec do
+  @runner.run_spec!
+end
+
+task :controlrepo_autotest_acceptance do
+  @runner.run_acceptance!
+end
+
+task :controlrepo_spec => [
+  :controlrepo_autotest_prep,
+  :controlrepo_autotest_spec
+  ]
+
+task :controlrepo_acceptance => [
+  :controlrepo_autotest_prep,
+  :controlrepo_autotest_acceptance
+  ]
+
+task :controlrepo_temp_create do
+  require 'onceover/testconfig'
+  repo = Onceover::Controlrepo.new
+  config = Onceover::TestConfig.new("#{repo.spec_dir}/controlrepo.yaml")
+  FileUtils.rm_rf(repo.tempdir)
+  # Deploy r10k to a temp dir
+  config.r10k_deploy_local(repo)
+end

data/lib/onceover/runner.rb

@@ -0,0 +1,90 @@
+class Onceover
+  class Runner
+    attr_reader :repo
+    attr_reader :config
+
+    def initialize(repo, config, mode = [:spec, :acceptance])
+      @repo   = repo
+      @config = config
+      @mode   = [mode].flatten
+    end
+
+    def prepare!
+      # Deploy the puppetfile
+      @config.r10k_deploy_local(@repo)
+
+      # Remove the entire spec directory to make sure we have
+      # all the latest tests
+      FileUtils.rm_rf("#{@repo.tempdir}/spec")
+
+      # Create the other directories we need
+      FileUtils.mkdir_p("#{@repo.tempdir}/spec/classes")
+      FileUtils.mkdir_p("#{@repo.tempdir}/spec/acceptance/nodesets")
+
+      # Copy our entire spec directory over
+      FileUtils.cp_r("#{@repo.spec_dir}","#{@repo.tempdir}")
+
+      # Create the Rakefile so that we can take advantage of the existing tasks
+      @config.write_rakefile(@repo.tempdir, "spec/classes/**/*_spec.rb")
+
+      # Create spec_helper.rb
+      @config.write_spec_helper("#{@repo.tempdir}/spec",@repo)
+
+      # Create spec_helper_accpetance.rb
+      @config.write_spec_helper_acceptance("#{@repo.tempdir}/spec",@repo)
+
+      # TODO: Remove all tests that do not match set tags
+
+      if @mode.include?(:spec)
+        # Verify all of the spec tests
+        @config.spec_tests.each { |test| @config.verify_spec_test(@repo,test) }
+
+        # Deduplicate and write the tests (Spec and Acceptance)
+        @config.run_filters(Onceover::Test.deduplicate(@config.spec_tests)).each do |test|
+          @config.write_spec_test("#{@repo.tempdir}/spec/classes",test)
+        end
+      end
+
+      if @mode.include?(:acceptance)
+        # Verify all of the acceptance tests
+        @config.acceptance_tests.each { |test| @config.verify_acceptance_test(@repo,test) }
+
+        # Write them out
+        @config.write_acceptance_tests("#{@repo.tempdir}/spec/acceptance",@config.run_filters(Onceover::Test.deduplicate(@config.acceptance_tests)))
+      end
+
+      # Parse the current hiera config, modify, and write it to the temp dir
+      unless @repo.hiera_config ==nil
+        hiera_config = @repo.hiera_config
+        hiera_config.each do |setting,value|
+          if value.is_a?(Hash)
+            if value.has_key?(:datadir)
+              hiera_config[setting][:datadir] = "#{@repo.tempdir}/#{@repo.environmentpath}/production/#{value[:datadir]}"
+            end
+          end
+        end
+        File.write("#{@repo.tempdir}/#{@repo.environmentpath}/production/hiera.yaml",hiera_config.to_yaml)
+      end
+
+      @config.create_fixtures_symlinks(@repo)
+    end
+
+    def run_spec!
+      Dir.chdir(@repo.tempdir) do
+        #`bundle install --binstubs`
+        #`bin/rake spec_standalone`
+        logger.debug "Running bundle exec rake spec_standalone from #{@repo.tempdir}"
+        exec("bundle exec rake spec_standalone")
+      end
+    end
+
+    def run_acceptance!
+      Dir.chdir(@repo.tempdir) do
+        #`bundle install --binstubs`
+        #`bin/rake spec_standalone`
+        logger.debug "Running bundle exec rake acceptance from #{@repo.tempdir}"
+        exec("bundle exec rake acceptance")
+      end
+    end
+  end
+end

data/lib/onceover/test.rb

@@ -0,0 +1,157 @@
+class Onceover
+  class Test
+    @@all =[]
+
+    attr_accessor :nodes
+    attr_accessor :classes
+    attr_accessor :test_config
+    attr_reader   :default_test_config
+    attr_reader   :tags
+
+    # This can accept a bunch of stuff. It can accept nodes, classes or groups anywhere
+    # it will then detect them and expand them out into their respective objects so that
+    # we just end up with a list of nodes and classes
+    #def initialize(on_this,test_config['classes'],options = {})
+    def initialize(on_this,test_this,test_config)
+
+      @default_test_config = {
+        'check_idempotency' => true,
+        'runs_before_idempotency' => 1
+      }
+
+      # Add defaults if they do not exist
+      test_config = @default_test_config.merge(test_config)
+
+      @nodes = []
+      @classes = []
+      @test_config = test_config
+      @test_config.delete('classes') # remove classes from the config
+      @tags = @test_config['tags']
+
+
+      # Make sure that tags are an array
+      @test_config['tags'] = [@test_config['tags']].flatten if @test_config['tags']
+
+      # Get the nodes we are working on
+      if Onceover::Group.find(on_this)
+        @nodes << Onceover::Group.find(on_this).members
+      elsif Onceover::Node.find(on_this)
+        @nodes << Onceover::Node.find(on_this)
+      else
+        raise "#{on_this} was not found in the list of nodes or groups!"
+      end
+
+      @nodes.flatten!
+
+      # Check that our nodes list contains only nodes
+      raise "#{@nodes} contained a non-node object." unless @nodes.all? { |item| item.is_a?(Onceover::Node) }
+
+      if test_this.is_a?(String)
+        # If we have just given a string then grab all the classes it corresponds to
+        if Onceover::Group.find(test_this)
+          @classes << Onceover::Group.find(test_this).members
+        elsif Onceover::Class.find(test_this)
+          @classes << Onceover::Class.find(test_this)
+        else
+          raise "#{test_this} was not found in the list of classes or groups!"
+        end
+        @classes.flatten!
+      elsif test_this.is_a?(Hash)
+        # If it is a hash we need to get creative
+
+        # Get all of the included classes and add them
+        if Onceover::Group.find(test_this['include'])
+          @classes << Onceover::Group.find(test_this['include']).members
+        elsif Onceover::Class.find(test_this['include'])
+          @classes << Onceover::Class.find(test_this['include'])
+        else
+          raise "#{test_this['include']} was not found in the list of classes or groups!"
+        end
+        @classes.flatten!
+
+        # Then remove any excluded ones
+        if Onceover::Group.find(test_this['exclude'])
+          Onceover::Group.find(test_this['exclude']).members.each do |clarse|
+            @classes.delete(clarse)
+          end
+        elsif Onceover::Class.find(test_this['exclude'])
+          @classes.delete(Onceover::Class.find(test_this['exclude']))
+        else
+          raise "#{test_this['exclude']} was not found in the list of classes or groups!"
+        end
+      elsif test_this.is_a?(Onceover::Class)
+        @classes << test_this
+      end
+    end
+
+    def eql?(other)
+      (@nodes.sort.eql?(other.nodes.sort)) and (@classes.sort.eql?(other.classes.sort))
+    end
+
+    def to_s
+      class_msg = ""
+      node_msg = ""
+      if classes.count > 1
+        class_msg = "#{classes.count}_classes"
+      else
+        class_msg = classes[0].name
+      end
+
+      if nodes.count > 1
+        node_msg = "#{nodes.count}_nodes"
+      else
+        node_msg = nodes[0].name
+      end
+
+      "#{class_msg}_on_#{node_msg}"
+    end
+
+    def self.deduplicate(tests)
+      require 'deep_merge'
+      # This should take an array of tests and remove any duplicates from them
+
+      # this will be an array of arrays, or maybe hashes
+      combinations = []
+      new_tests = []
+      tests.each do |test|
+        test.nodes.each do |node|
+          test.classes.each do |cls|
+            combo = {node => cls}
+            if combinations.member?(combo)
+
+              # Find the right test object:
+              relevant_test = new_tests[new_tests.index do |a|
+                a.nodes[0] == node and a.classes[0] == cls
+              end]
+
+              # Delete all default values in the current options hash
+              test.test_config.delete_if do |key,value|
+                test.default_test_config[key] == value
+              end
+
+              # Merge the non-default options right on in there
+              relevant_test.test_config.deep_merge!(test.test_config)
+            else
+              combinations << combo
+              new_tests << Onceover::Test.new(node,cls,test.test_config)
+            end
+          end
+        end
+      end
+
+      # The array that this returns should be ephemeral, it does not
+      # represent anything defined in a controlrepo and should just
+      # be passed into the thing doing the testing and then killed,
+      # we don't want too many copies of the same shit going around
+      #
+      # Actually based on the way things are written I don't think this
+      # will duplicated node or class objects, just test objects,
+      # everything else is passed by reference
+      new_tests
+    end
+
+    def self.all
+      @@all
+    end
+  end
+end