jamie 0.1.0.alpha20 → 0.1.0.alpha21

data/jamie.gemspec

@@ -6,6 +6,7 @@ require 'jamie/version'
 Gem::Specification.new do |gem|
   gem.name          = "jamie"
   gem.version       = Jamie::VERSION
+  gem.license       = 'Apache 2.0'
   gem.authors       = ["Fletcher Nichol"]
   gem.email         = ["fnichol@nichol.ca"]
   gem.description   = %q{A Chef convergence integration test harness}

data/lib/jamie/cli.rb

@@ -16,6 +16,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'benchmark'
 require 'ostruct'
 require 'thor'
 
@@ -29,6 +30,7 @@ module Jamie
   class CLI < Thor
 
     include Thor::Actions
+    include Logging
 
     # Constructs a new instance.
     def initialize(*args)
@@ -64,12 +66,16 @@ module Jamie
     method_option :destroy, :aliases => "-d", :default => "passing",
       :desc => "Destroy strategy to use after testing (passing, always, never)."
     def test(*args)
-      destroy_mode = options[:destroy]
-      if ! %w{passing always never}.include?(options[:destroy])
-        raise ArgumentError, "Destroy mode must be passing, always, or never."
+      banner "Starting Jamie"
+      elapsed = Benchmark.measure do
+        destroy_mode = options[:destroy]
+        if ! %w{passing always never}.include?(options[:destroy])
+          raise ArgumentError, "Destroy mode must be passing, always, or never."
+        end
+        result = parse_subcommand(args.first)
+        Array(result).each { |instance| instance.test(destroy_mode.to_sym) }
       end
-      result = parse_subcommand(args.first)
-      Array(result).each { |instance| instance.test(destroy_mode.to_sym) }
+      banner "Jamie is finished. (#{elapsed.real} seconds)"
     end
 
     desc "login (['REGEX']|[INSTANCE])", "Log in to one instance"
@@ -118,10 +124,18 @@ module Jamie
 
     attr_reader :task
 
+    def logger
+      Jamie.logger
+    end
+
     def exec_action(action)
-      @task = action
-      result = parse_subcommand(args.first)
-      Array(result).each { |instance| instance.send(task) }
+      banner "Starting Jamie"
+      elapsed = Benchmark.measure do
+        @task = action
+        result = parse_subcommand(args.first)
+        Array(result).each { |instance| instance.send(task) }
+      end
+      banner "Jamie is finished. (#{elapsed.real} seconds)"
     end
 
     def parse_subcommand(arg = nil)

data/lib/jamie/driver/dummy.rb

@@ -27,10 +27,11 @@ module Jamie
     # @author Fletcher Nichol <fnichol@nichol.ca>
     class Dummy < Jamie::Driver::Base
 
-      default_config 'sleep', 0
+      default_config :sleep, 0
+      default_config :random_failure, false
 
       def create(state)
-        state['my_id'] = "#{instance.name}-#{Time.now.to_i}"
+        state[:my_id] = "#{instance.name}-#{Time.now.to_i}"
         report(:create, state)
       end
 
@@ -48,7 +49,7 @@ module Jamie
 
       def destroy(state)
         report(:destroy, state)
-        state.delete('my_id')
+        state.delete(:my_id)
       end
 
       private
@@ -56,8 +57,12 @@ module Jamie
       def report(action, state)
         info("[Dummy] Action ##{action} called on " +
           "instance=#{instance} with state=#{state}")
-        sleep(config['sleep'].to_f) if config['sleep'].to_f > 0.0
-        debug("[Dummy] Action ##{action} completed (#{config['sleep']}s).")
+        sleep(config[:sleep].to_f) if config[:sleep].to_f > 0.0
+        if config[:random_failure] && [true, false].sample
+          debug("[Dummy] Random failure for action ##{action}.")
+          raise ActionFailed, "Action ##{action} failed for #{instance.to_str}."
+        end
+        debug("[Dummy] Action ##{action} completed (#{config[:sleep]}s).")
       end
     end
   end

data/lib/jamie/version.rb

@@ -18,5 +18,5 @@
 
 module Jamie
 
-  VERSION = "0.1.0.alpha20"
+  VERSION = "0.1.0.alpha21"
 end

data/lib/jamie.rb

@@ -88,14 +88,14 @@ module Jamie
     #   convergence integration
     def platforms
       @platforms ||= Collection.new(
-        Array(yaml["platforms"]).map { |hash| new_platform(hash) })
+        Array(yaml[:platforms]).map { |hash| new_platform(hash) })
     end
 
     # @return [Array<Suite>] all defined suites which will be used in
     #   convergence integration
     def suites
       @suites ||= Collection.new(
-        Array(yaml["suites"]).map { |hash| new_suite(hash) })
+        Array(yaml[:suites]).map { |hash| new_suite(hash) })
     end
 
     # @return [Array<Instance>] all instances, resulting from all platform and
@@ -163,12 +163,11 @@ module Jamie
     private
 
     def new_suite(hash)
-      data_bags_path = calculate_data_bags_path(hash['name'])
-      roles_path = calculate_roles_path(hash['name'])
       path_hash = {
-        'data_bags_path' => data_bags_path,
-        'roles_path'     => roles_path
+        :data_bags_path => calculate_path("data_bags", hash[:name]),
+        :roles_path     => calculate_path("roles", hash[:name]),
       }
+
       Suite.new(hash.rmerge(path_hash))
     end
 
@@ -177,9 +176,10 @@ module Jamie
     end
 
     def new_driver(hash)
-      hash['driver_config'] ||= Hash.new
-      hash['driver_config']['jamie_root'] = jamie_root
-      Driver.for_plugin(hash['driver_plugin'], hash['driver_config'])
+      hash[:driver_config] ||= Hash.new
+      hash[:driver_config][:jamie_root] = jamie_root
+
+      Driver.for_plugin(hash[:driver_plugin], hash[:driver_config])
     end
 
     def new_instance(suite, platform)
@@ -189,18 +189,18 @@ module Jamie
       FileUtils.mkdir_p(log_root)
 
       Instance.new(
-        'suite'     => suite,
-        'platform'  => platform,
-        'driver'    => driver,
-        'jr'        => Jr.new(suite.name),
-        'logger'    => new_instance_logger(log_root)
+        :suite    => suite,
+        :platform => platform,
+        :driver   => driver,
+        :jr       => Jr.new(suite.name),
+        :logger   => new_instance_logger(log_root)
       )
     end
 
     def platform_driver_hash(platform_name)
-      h = yaml['platforms'].find { |p| p['name'] == platform_name } || Hash.new
+      h = yaml[:platforms].find { |p| p[:name] == platform_name } || Hash.new
 
-      h.select { |key, value| %w(driver_plugin driver_config).include?(key) }
+      h.select { |key, value| [ :driver_plugin, :driver_config ].include?(key) }
     end
 
     def new_instance_logger(log_root)
@@ -215,7 +215,8 @@ module Jamie
     end
 
     def yaml
-      @yaml ||= YAML.load(yaml_contents).rmerge(local_yaml)
+      @yaml ||= Util.symbolized_hash(
+        YAML.load(yaml_contents).rmerge(local_yaml))
     end
 
     def yaml_contents
@@ -245,44 +246,30 @@ module Jamie
       default_driver_hash.rmerge(common_driver_hash.rmerge(driver_hash))
     end
 
-    def calculate_roles_path(suite_name)
-      suite_roles_path = File.join(test_base_path, suite_name, "roles")
-      common_roles_path = File.join(test_base_path, "roles")
-      top_level_roles_path = File.join(Dir.pwd, "roles")
-
-      if File.directory?(suite_roles_path)
-        suite_roles_path
-      elsif File.directory?(common_roles_path)
-        common_roles_path
-      elsif File.directory?(top_level_roles_path)
-        top_level_roles_path
-      else
-        nil
-      end
-    end
-
-    def calculate_data_bags_path(suite_name)
-      suite_data_bags_path = File.join(test_base_path, suite_name, "data_bags")
-      common_data_bags_path = File.join(test_base_path, "data_bags")
-      top_level_data_bags_path = File.join(Dir.pwd, "data_bags")
+    def calculate_path(path, suite_name)
+      suite_path      = File.join(test_base_path, suite_name, path)
+      common_path     = File.join(test_base_path, path)
+      top_level_path  = File.join(Dir.pwd, path)
 
-      if File.directory?(suite_data_bags_path)
-        suite_data_bags_path
-      elsif File.directory?(common_data_bags_path)
-        common_data_bags_path
-      elsif File.directory?(top_level_data_bags_path)
-        top_level_data_bags_path
+      if File.directory?(suite_path)
+        suite_path
+      elsif File.directory?(common_path)
+        common_path
+      elsif File.directory?(top_level_path)
+        top_level_path
       else
         nil
       end
     end
 
     def default_driver_hash
-      { 'driver_plugin' => DEFAULT_DRIVER_PLUGIN, 'driver_config' => {} }
+      { :driver_plugin => DEFAULT_DRIVER_PLUGIN, :driver_config => {} }
     end
 
     def common_driver_hash
-      yaml.select { |key, value| %w(driver_plugin driver_config).include?(key) }
+      yaml.select do |key, value|
+        [ :driver_plugin, :driver_config ].include?(key)
+      end
     end
   end
 
@@ -445,20 +432,21 @@ module Jamie
     #   (**Required**)
     # @option options [Hash] :attributes Hash of Chef node attributes
     # @option options [String] :data_bags_path path to data bags
+    # @option options [String] :roles_path path to roles
     def initialize(options = {})
       validate_options(options)
 
-      @name = options['name']
-      @run_list = options['run_list']
-      @attributes = options['attributes'] || Hash.new
-      @data_bags_path = options['data_bags_path']
-      @roles_path = options['roles_path']
+      @name = options[:name]
+      @run_list = options[:run_list]
+      @attributes = options[:attributes] || Hash.new
+      @data_bags_path = options[:data_bags_path]
+      @roles_path = options[:roles_path]
     end
 
     private
 
     def validate_options(opts)
-      %w(name run_list).each do |k|
+      [ :name, :run_list ].each do |k|
         raise ArgumentError, "Attribute '#{k}' is required." if opts[k].nil?
       end
     end
@@ -491,15 +479,15 @@ module Jamie
     def initialize(options = {})
       validate_options(options)
 
-      @name = options['name']
-      @run_list = Array(options['run_list'])
-      @attributes = options['attributes'] || Hash.new
+      @name = options[:name]
+      @run_list = Array(options[:run_list])
+      @attributes = options[:attributes] || Hash.new
     end
 
     private
 
     def validate_options(opts)
-      %w(name).each do |k|
+      [ :name ].each do |k|
         raise ArgumentError, "Attribute '#{k}' is required." if opts[k].nil?
       end
     end
@@ -539,14 +527,14 @@ module Jamie
     # @option options [Jr] :jr the jr command string generator
     # @option options [Logger] :logger the instance logger
     def initialize(options = {})
-      options = { 'logger' => Jamie.logger }.merge(options)
+      options = { :logger => Jamie.logger }.merge(options)
       validate_options(options)
-      logger = options['logger']
+      logger = options[:logger]
 
-      @suite = options['suite']
-      @platform = options['platform']
-      @driver = options['driver']
-      @jr = options['jr']
+      @suite = options[:suite]
+      @platform = options[:platform]
+      @driver = options[:driver]
+      @jr = options[:jr]
       @logger = logger.is_a?(Proc) ? logger.call(name) : logger
 
       @driver.instance = self
@@ -557,7 +545,7 @@ module Jamie
       "#{suite.name}-#{platform.name}".gsub(/_/, '-').gsub(/\./, '')
     end
 
-    def to_s
+    def to_str
       "<#{name}>"
     end
 
@@ -578,7 +566,7 @@ module Jamie
     end
 
     def dna
-      attributes.rmerge({ 'run_list' => run_list })
+      attributes.rmerge({ :run_list => run_list })
     end
 
     # Creates this instance.
@@ -648,13 +636,13 @@ module Jamie
     #   to gracfully stop action chaining
     def test(destroy_mode = :passing)
       elapsed = Benchmark.measure do
-        banner "Cleaning up any prior instances of #{self}"
+        banner "Cleaning up any prior instances of #{to_str}"
         destroy
-        banner "Testing #{self}"
+        banner "Testing #{to_str}"
         verify
         destroy if destroy_mode == :passing
       end
-      info "Testing of #{self} complete (#{elapsed.real} seconds)."
+      info "Finished testing #{to_str} (#{elapsed.real} seconds)."
       self
     ensure
       destroy if destroy_mode == :always
@@ -677,7 +665,7 @@ module Jamie
     private
 
     def validate_options(opts)
-      %w(suite platform driver jr logger).each do |k|
+      [ :suite, :platform, :driver, :jr, :logger ].each do |k|
         raise ArgumentError, "Attribute '#{k}' is required." if opts[k].nil?
       end
     end
@@ -691,38 +679,31 @@ module Jamie
     end
 
     def create_action
-      banner "Creating #{self}"
-      elapsed = action(:create) { |state| driver.create(state) }
-      info "Creation of #{self} complete (#{elapsed.real} seconds)."
-      self
+      perform_action(:create, "Creating")
     end
 
     def converge_action
-      banner "Converging #{self}"
-      elapsed = action(:converge) { |state| driver.converge(state) }
-      info "Convergence of #{self} complete (#{elapsed.real} seconds)."
-      self
+      perform_action(:converge, "Converging")
     end
 
     def setup_action
-      banner "Setting up #{self}"
-      elapsed = action(:setup) { |state| driver.setup(state) }
-      info "Setup of #{self} complete (#{elapsed.real} seconds)."
-      self
+      perform_action(:setup, "Setting up")
     end
 
     def verify_action
-      banner "Verifying #{self}"
-      elapsed = action(:verify) { |state| driver.verify(state) }
-      info "Verification of #{self} complete (#{elapsed.real} seconds)."
-      self
+      perform_action(:verify, "Verifying")
     end
 
     def destroy_action
-      banner "Destroying #{self}"
-      elapsed = action(:destroy) { |state| driver.destroy(state) }
-      destroy_state
-      info "Destruction of #{self} complete (#{elapsed.real} seconds)."
+      perform_action(:destroy, "Destroying") { destroy_state }
+    end
+
+    def perform_action(verb, output_verb)
+      banner "#{output_verb} #{to_str}"
+      elapsed = action(verb) { |state| driver.public_send(verb, state) }
+      info("Finished #{output_verb.downcase} #{to_str}" +
+           " (#{elapsed.real} seconds).")
+      yield if block_given?
       self
     end
 
@@ -731,14 +712,18 @@ module Jamie
       elapsed = Benchmark.measure do
         yield state if block_given?
       end
-      state['last_action'] = what.to_s
+      state[:last_action] = what.to_s
       elapsed
     ensure
       dump_state(state)
     end
 
     def load_state
-      File.exists?(statefile) ?  YAML.load_file(statefile) : Hash.new
+      if File.exists?(statefile)
+        Util.symbolized_hash(YAML.load_file(statefile))
+      else
+        Hash.new
+      end
     end
 
     def dump_state(state)
@@ -754,12 +739,12 @@ module Jamie
 
     def statefile
       File.expand_path(File.join(
-        driver['jamie_root'], ".jamie", "#{name}.yml"
+        driver[:jamie_root], ".jamie", "#{name}.yml"
       ))
     end
 
     def last_action
-      load_state['last_action']
+      load_state[:last_action]
     end
 
     # The simplest finite state machine pseudo-implementation needed to manage
@@ -974,6 +959,16 @@ module Jamie
       else :fatal
       end
     end
+
+    def self.symbolized_hash(obj)
+      if obj.is_a?(Hash)
+        obj.inject({}) { |h, (k,v)| h[k.to_sym] = symbolized_hash(v) ; h }
+      elsif obj.is_a?(Array)
+        obj.inject([]) { |a, v| a << symbolized_hash(v) ; a }
+      else
+        obj
+      end
+    end
   end
 
   # Mixin that wraps a command shell out invocation, providing a #run_command
@@ -1114,7 +1109,7 @@ module Jamie
       end
 
       def run_command(cmd, use_sudo = nil, log_subject = nil)
-        use_sudo = config['use_sudo'] if use_sudo.nil?
+        use_sudo = config[:use_sudo] if use_sudo.nil?
         log_subject = Util.to_snake_case(self.class.to_s)
 
         super(cmd, use_sudo, log_subject)
@@ -1144,7 +1139,7 @@ module Jamie
       def converge(state)
         ssh_args = build_ssh_args(state)
 
-        install_omnibus(ssh_args) if config['require_chef_omnibus']
+        install_omnibus(ssh_args) if config[:require_chef_omnibus]
         prepare_chef_home(ssh_args)
         upload_chef_data(ssh_args)
         run_chef_solo(ssh_args)
@@ -1174,8 +1169,8 @@ module Jamie
       def login_command(state)
         args  = %W{ -o UserKnownHostsFile=/dev/null }
         args += %W{ -o StrictHostKeyChecking=no }
-        args += %W{ -i #{config['ssh_key']}} if config['ssh_key']
-        args += %W{ #{config['username']}@#{state['hostname']}}
+        args += %W{ -i #{config[:ssh_key]}} if config[:ssh_key]
+        args += %W{ #{config[:username]}@#{state[:hostname]}}
 
         ["ssh", *args]
       end
@@ -1186,10 +1181,10 @@ module Jamie
         opts = Hash.new
         opts[:user_known_hosts_file] = "/dev/null"
         opts[:paranoid] = false
-        opts[:password] = config['password'] if config['password']
-        opts[:keys] = Array(config['ssh_key']) if config['ssh_key']
+        opts[:password] = config[:password] if config[:password]
+        opts[:keys] = Array(config[:ssh_key]) if config[:ssh_key]
 
-        [ state['hostname'], config['username'], opts ]
+        [ state[:hostname], config[:username], opts ]
       end
 
       def chef_home
@@ -1210,7 +1205,7 @@ module Jamie
 
       def upload_chef_data(ssh_args)
         Jamie::ChefDataUploader.new(
-          instance, ssh_args, config['jamie_root'], chef_home
+          instance, ssh_args, config[:jamie_root], chef_home
         ).upload
       end
 
@@ -1262,7 +1257,7 @@ module Jamie
       end
 
       def test_ssh(hostname)
-        socket = TCPSocket.new(hostname, config['port'])
+        socket = TCPSocket.new(hostname, config[:port])
         IO.select([socket], nil, nil, 5)
       rescue SocketError, Errno::ECONNREFUSED,
           Errno::EHOSTUNREACH, Errno::ENETUNREACH, IOError
@@ -1321,36 +1316,25 @@ module Jamie
     end
 
     def upload_cookbooks(scp)
-      ckbks_dir = local_cookbooks
-      scp.upload!(ckbks_dir, "#{chef_home}/cookbooks",
-        :recursive => true
-      ) do |ch, name, sent, total|
-        if sent == total
-          info("Uploaded #{name.sub(%r{^#{ckbks_dir}/}, '')} (#{total} bytes)")
-        end
-      end
+      cookbooks_dir = local_cookbooks
+      upload_path(scp, cookbooks_dir, "cookbooks")
     ensure
-      FileUtils.rmtree(ckbks_dir)
+      FileUtils.rmtree(cookbooks_dir)
     end
 
     def upload_data_bags(scp)
-      dbags_dir = instance.suite.data_bags_path
-      scp.upload!(dbags_dir, "#{chef_home}/data_bags",
-        :recursive => true
-      ) do |ch, name, sent, total|
-        if sent == total
-          info("Uploaded #{name.sub(%r{^#{dbags_dir}/}, '')} (#{total} bytes)")
-        end
-      end
+      upload_path(scp, instance.suite.data_bags_path)
     end
 
     def upload_roles(scp)
-      roles_dir = instance.suite.roles_path
-      scp.upload!(roles_dir, "#{chef_home}/roles",
-        :recursive => true
+      upload_path(scp, instance.suite.roles_path)
+    end
+
+    def upload_path(scp, path, dir = File.basename(path))
+      scp.upload!(path, "#{chef_home}/#{dir}", :recursive => true
       ) do |ch, name, sent, total|
         if sent == total
-          info("Uploaded #{name.sub(%r{^#{roles_dir}/}, '')} (#{total} bytes)")
+          info("Uploaded #{name.sub(%r{^#{path}/}, '')} (#{total} bytes)")
         end
       end
     end
@@ -1389,7 +1373,7 @@ module Jamie
     def run_berks(tmpdir)
       begin
         run_command "if ! command -v berks >/dev/null; then exit 1; fi"
-      rescue Mixlib::ShellOut::ShellCommandFailed
+      rescue Jamie::ShellOut::ShellCommandFailed
         abort ">>>>>> Berkshelf must be installed, add it to your Gemfile."
       end
       run_command "berks install --path #{tmpdir}"
@@ -1398,7 +1382,7 @@ module Jamie
     def run_librarian(tmpdir)
       begin
         run_command "if ! command -v librarian-chef >/dev/null; then exit 1; fi"
-      rescue Mixlib::ShellOut::ShellCommandFailed
+      rescue Jamie::ShellOut::ShellCommandFailed
         abort ">>>>>> Librarian must be installed, add it to your Gemfile."
       end
       run_command "librarian-chef install --path #{tmpdir}"

data/spec/jamie_spec.rb

@@ -151,7 +151,7 @@ describe Jamie::Config do
         'platforms' => [ { 'name' => 'platform', 'driver_plugin' => 'dummy' } ],
         'suites' => [ { 'name' => 'suite', 'run_list' => [] }]
       })
-      config.instances.first.driver['jamie_root'].must_equal "/tmp"
+      config.instances.first.driver[:jamie_root].must_equal "/tmp"
     end
 
     it "returns an instance with a driver initialized with passed in config" do
@@ -162,7 +162,7 @@ describe Jamie::Config do
         ],
         'suites' => [ { 'name' => 'suite', 'run_list' => [] }]
       })
-      config.instances.first.driver['foo'].must_equal "bar"
+      config.instances.first.driver[:foo].must_equal "bar"
     end
   end
 
@@ -176,7 +176,7 @@ describe Jamie::Config do
       stub_yaml!(".jamie.local.yml", {
         'driver_config' => { 'foo' => 'bar' }
       })
-      config.instances.first.driver['foo'].must_equal 'bar'
+      config.instances.first.driver[:foo].must_equal 'bar'
     end
 
     it "merges over configuration in jamie.yml" do
@@ -188,7 +188,7 @@ describe Jamie::Config do
       stub_yaml!(".jamie.local.yml", {
         'driver_config' => { 'foo' => 'bar' }
       })
-      config.instances.first.driver['foo'].must_equal 'bar'
+      config.instances.first.driver[:foo].must_equal 'bar'
     end
   end
 
@@ -222,8 +222,8 @@ describe Jamie::Config do
           <% end %>
         YAML
       end
-      config.instances.first.driver['noodle'].must_equal "soup"
-      config.instances.first.driver['mushroom'].must_equal "soup"
+      config.instances.first.driver[:noodle].must_equal "soup"
+      config.instances.first.driver[:mushroom].must_equal "soup"
     end
   end
 
@@ -307,16 +307,16 @@ end
 
 describe Jamie::Suite do
 
-  let(:opts) do ; { 'name' => 'suitezy', 'run_list' => [ 'doowah' ] } ; end
+  let(:opts) do ; { :name => 'suitezy', :run_list => [ 'doowah' ] } ; end
   let(:suite) { Jamie::Suite.new(opts) }
 
   it "raises an ArgumentError if name is missing" do
-    opts.delete('name')
+    opts.delete(:name)
     proc { Jamie::Suite.new(opts) }.must_raise ArgumentError
   end
 
   it "raises an ArgumentError if run_list is missing" do
-    opts.delete('run_list')
+    opts.delete(:run_list)
     proc { Jamie::Suite.new(opts) }.must_raise ArgumentError
   end
 
@@ -333,11 +333,11 @@ describe Jamie::Suite do
   end
 
   it "returns attributes from constructor" do
-    opts.merge!({ 'attributes' => { 'a' => 'b' }, 'data_bags_path' => 'crazy',
-                  'roles_path' => 'town' })
+    opts.merge!({ :attributes => { :a => 'b' }, :data_bags_path => 'crazy',
+                  :roles_path => 'town' })
     suite.name.must_equal 'suitezy'
     suite.run_list.must_equal [ 'doowah' ]
-    suite.attributes.must_equal({ 'a' => 'b' })
+    suite.attributes.must_equal({ :a => 'b' })
     suite.data_bags_path.must_equal 'crazy'
     suite.roles_path.must_equal 'town'
   end
@@ -345,11 +345,11 @@ end
 
 describe Jamie::Platform do
 
-  let(:opts) do ; { 'name' => 'plata' } ; end
+  let(:opts) do ; { :name => 'plata' } ; end
   let(:platform) { Jamie::Platform.new(opts) }
 
   it "raises an ArgumentError if name is missing" do
-    opts.delete('name')
+    opts.delete(:name)
     proc { Jamie::Platform.new(opts) }.must_raise ArgumentError
   end
 
@@ -362,23 +362,23 @@ describe Jamie::Platform do
   end
 
   it "returns attributes from constructor" do
-    opts.merge!({ 'run_list' => [ 'a', 'b' ], 'attributes' => { 'c' => 'd' }})
+    opts.merge!({ :run_list => [ 'a', 'b' ], :attributes => { :c => 'd' }})
     platform.name.must_equal 'plata'
     platform.run_list.must_equal [ 'a', 'b' ]
-    platform.attributes.must_equal({ 'c' => 'd' })
+    platform.attributes.must_equal({ :c => 'd' })
   end
 end
 
 describe Jamie::Instance do
 
   let(:suite) do
-    Jamie::Suite.new({ 'name' => 'suite',
-      'run_list' => 'suite_list', 'attributes' => { 's' => 'ss' } })
+    Jamie::Suite.new({ :name => 'suite',
+      :run_list => 'suite_list', :attributes => { :s => 'ss' } })
   end
 
   let(:platform) do
-    Jamie::Platform.new({ 'name' => 'platform',
-      'run_list' => 'platform_list', 'attributes' => { 'p' => 'pp' } })
+    Jamie::Platform.new({ :name => 'platform',
+      :run_list => 'platform_list', :attributes => { :p => 'pp' } })
   end
 
   let(:driver) { Jamie::Driver::Dummy.new({}) }
@@ -386,18 +386,18 @@ describe Jamie::Instance do
   let(:jr) { Jamie::Jr.new(suite.name) }
 
   let(:opts) do
-    { 'suite' => suite, 'platform' => platform, 'driver' => driver, 'jr' => jr }
+    { :suite => suite, :platform => platform, :driver => driver, :jr => jr }
   end
 
   let(:instance) { Jamie::Instance.new(opts) }
 
   it "raises an ArgumentError if suite is missing" do
-    opts.delete('suite')
+    opts.delete(:suite)
     proc { Jamie::Instance.new(opts) }.must_raise ArgumentError
   end
 
   it "raises an ArgumentError if platform is missing" do
-    opts.delete('platform')
+    opts.delete(:platform)
     proc { Jamie::Instance.new(opts) }.must_raise ArgumentError
   end
 
@@ -416,11 +416,11 @@ describe Jamie::Instance do
   describe "#name" do
 
     def combo(suite_name, platform_name)
-      opts['suite'] = Jamie::Suite.new(
-        'name' => suite_name, 'run_list' => []
+      opts[:suite] = Jamie::Suite.new(
+        :name => suite_name, :run_list => []
       )
-      opts['platform'] = Jamie::Platform.new(
-        'name' => platform_name
+      opts[:platform] = Jamie::Platform.new(
+        :name => platform_name
       )
       Jamie::Instance.new(opts)
     end
@@ -445,11 +445,11 @@ describe Jamie::Instance do
   describe "#run_list" do
 
     def combo(suite_list, platform_list)
-      opts['suite'] = Jamie::Suite.new(
-        'name' => 'suite', 'run_list' => suite_list
+      opts[:suite] = Jamie::Suite.new(
+        :name => 'suite', :run_list => suite_list
       )
-      opts['platform'] = Jamie::Platform.new(
-        'name' => 'platform', 'run_list' => platform_list
+      opts[:platform] = Jamie::Platform.new(
+        :name => 'platform', :run_list => platform_list
       )
       Jamie::Instance.new(opts)
     end
@@ -470,37 +470,37 @@ describe Jamie::Instance do
   describe "#attributes" do
 
     def combo(suite_attrs, platform_attrs)
-      opts['suite'] = Jamie::Suite.new(
-        'name' => 'suite', 'run_list' => [], 'attributes' => suite_attrs
+      opts[:suite] = Jamie::Suite.new(
+        :name => 'suite', :run_list => [], :attributes => suite_attrs
       )
-      opts['platform'] = Jamie::Platform.new(
-        'name' => 'platform', 'attributes' => platform_attrs
+      opts[:platform] = Jamie::Platform.new(
+        :name => 'platform', :attributes => platform_attrs
       )
       Jamie::Instance.new(opts)
     end
 
     it "merges suite and platform hashes together" do
       combo(
-        { 'suite' => { 's1' => 'sv1' } },
-        { 'suite' => { 'p1' => 'pv1' }, 'platform' => 'pp' }
+        { :suite => { :s1 => 'sv1' } },
+        { :suite => { :p1 => 'pv1' }, :platform => 'pp' }
       ).attributes.must_equal({
-        'suite' => { 's1' => 'sv1', 'p1' => 'pv1' },
-        'platform' => 'pp'
+        :suite => { :s1 => 'sv1', :p1 => 'pv1' },
+        :platform => 'pp'
       })
     end
 
     it "merges suite values over platform values" do
       combo(
-        { 'common' => { 'c1' => 'xxx' } },
-        { 'common' => { 'c1' => 'cv1', 'c2' => 'cv2' } },
+        { :common => { :c1 => 'xxx' } },
+        { :common => { :c1 => 'cv1', :c2 => 'cv2' } },
       ).attributes.must_equal({
-        'common' => { 'c1' => 'xxx', 'c2' => 'cv2' }
+        :common => { :c1 => 'xxx', :c2 => 'cv2' }
       })
     end
   end
 
   it "#dna combines attributes with the run_list" do
-    instance.dna.must_equal({ 's' => 'ss', 'p' => 'pp',
-      'run_list' => [ 'platform_list', 'suite_list' ] })
+    instance.dna.must_equal({ :s => 'ss', :p => 'pp',
+      :run_list => [ 'platform_list', 'suite_list' ] })
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jamie
 version: !ruby/object:Gem::Version
-  version: 0.1.0.alpha20
+  version: 0.1.0.alpha21
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-04 00:00:00.000000000 Z
+date: 2013-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -253,7 +253,8 @@ files:
 - templates/plugin/license_reserved.erb
 - templates/plugin/version.rb.erb
 homepage: https://github.com/jamie-ci/jamie
-licenses: []
+licenses:
+- Apache 2.0
 post_install_message: 
 rdoc_options: []
 require_paths: