knife_sous 0.0.1

data/lib/templates/nodes.example.rb

@@ -0,0 +1,32 @@
+# def vagrant_ssh_config_file
+#   @vagrant_ssh_config_file ||=begin
+#     config_file = Tempfile.new('vagrant_ssh_config')
+#     config_file.write(`vagrant ssh-config`)
+#     config_file.close
+#     at_exit { config_file.delete }
+#     config_file
+#   end
+#   @vagrant_ssh_config_file.path
+# end
+#
+# def default_node_options
+#   {
+#     user: 'deploy',
+#     node_config: 'nodes/server.json'
+#   }
+# end
+#
+# node :vagrant, node_config: 'nodes/something.json',
+#   hostname: 'default',
+#   ssh_config: vagrant_ssh_config_file
+#
+# namespace :production do |prod|
+#   prod.node :node_awesome, default_options.merge!(hostname: '00.12.34.56')
+#   prod.namespace :web do |web|
+#     web.node :nodetastic,
+#       hostname: "12.34.56.789",
+#       ssh_port: 22,
+#       identity_file: "path/to/identity"
+#   end
+# end
+#

data/spec/lib/chef/knife/sous_bootstrap_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Chef::Knife::SousBootstrap do
+  include KnifeCommandHelpers
+
+  describe "#banner" do
+    it "should have display how to use command" do
+      command.banner.should == 'knife sous bootstrap [NAMESPACE] NODE'
+    end
+  end
+  it_should_behave_like "a node command" do
+    let(:node_command) { command }
+  end
+
+  describe "#solo_bootstrap_node" do
+    let(:node) { KnifeSous::Node.new('nodetastic') }
+    let(:cmd) { command }
+    let(:solo_bootstrap_command) { Chef::Knife::SoloBootstrap.new }
+
+    before do
+      Chef::Knife::SoloBootstrap.stub(new: solo_bootstrap_command)
+      solo_bootstrap_command.stub(:run)
+      cmd.stub(configure_command: solo_bootstrap_command)
+      node.update_config(
+        node_config: '/path/to/node/config',
+        hostname: 'host_ip'
+      )
+    end
+
+    it "should provide name to args and run" do
+      solo_bootstrap_command.should_receive(:run)
+      cmd.solo_bootstrap_node(node)
+
+      solo_bootstrap_command.name_args.should == %w[host_ip /path/to/node/config]
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SousBootstrap, *args)
+  end
+end
+

data/spec/lib/chef/knife/sous_clean_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Chef::Knife::SousClean do
+  include KnifeCommandHelpers
+
+  describe "#banner" do
+    it "should have display how to use command" do
+      command.banner.should == 'knife sous clean [NAMESPACE] NODE'
+    end
+  end
+  it_should_behave_like "a node command" do
+    let(:node_command) { command }
+  end
+
+  describe "#solo_clean_node" do
+    let(:node) { KnifeSous::Node.new('nodetastic') }
+    let(:cmd) { command }
+    let(:solo_clean_command) { Chef::Knife::SoloClean.new }
+
+    before do
+      Chef::Knife::SoloClean.stub(new: solo_clean_command)
+      solo_clean_command.stub(:run)
+      cmd.stub(configure_command: solo_clean_command)
+      node.update_config(
+        hostname: 'host_ip'
+      )
+    end
+
+    it "should provide name to args and run" do
+      solo_clean_command.should_receive(:run)
+      cmd.solo_clean_node(node)
+
+      solo_clean_command.name_args.should == %w[host_ip]
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SousClean, *args)
+  end
+end
+

data/spec/lib/chef/knife/sous_cook_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Chef::Knife::SousCook do
+  include KnifeCommandHelpers
+
+  describe "#banner" do
+    it "should have display how to use command" do
+      command.banner.should == 'knife sous cook [NAMESPACE] NODE'
+    end
+  end
+
+  describe "#check_args" do
+    it "should print error, show usage and exit if no args are passed in" do
+      cmd = command
+      cmd.ui.should_receive(:fatal).with("You need to specificy a node or namespace")
+      cmd.should_receive(:show_usage)
+      lambda { cmd.check_args}.should raise_error SystemExit
+    end
+  end
+
+  it_should_behave_like "a node command" do
+    let(:node_command) { command }
+  end
+
+  describe "#solo_cook_node" do
+    let(:node) { KnifeSous::Node.new('nodetastic') }
+    let(:cmd) { command }
+    let(:solo_cook_command) { Chef::Knife::SoloCook.new }
+
+    before do
+      Chef::Knife::SoloCook.stub(new: solo_cook_command)
+      solo_cook_command.stub(:run)
+      cmd.stub(configure_command: solo_cook_command)
+      node.update_config(
+        node_config: '/path/to/node/config',
+        hostname: 'host_ip'
+      )
+    end
+
+    it "should provide name to args and run" do
+      solo_cook_command.should_receive(:run)
+      cmd.solo_cook_node(node)
+
+      solo_cook_command.name_args.should == %w[host_ip /path/to/node/config]
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SousCook, *args)
+  end
+end
+

data/spec/lib/chef/knife/sous_init_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Chef::Knife::SousInit do
+  include KnifeCommandHelpers
+
+  describe "#banner" do
+    it "should have display how to use command" do
+      command.banner.should == 'knife sous init [DIRECTORY]'
+    end
+  end
+
+  describe "#copy_template" do
+    before do
+      FileUtils.stub(:mkdir_p)
+    end
+
+    it "should copy template to location if location is empty" do
+      cmd = command
+      File.stub(exists?: false)
+      cmd.stub(node_manifest_example_path: 'example location')
+
+      FileUtils.should_receive(:cp).with('example location', 'some/location/nodes.example.rb')
+      cmd.ui.should_receive(:msg).with("Example nodes.rb copied to some/location/nodes.example.rb")
+
+      cmd.copy_template('some/location')
+    end
+
+    it "should print an error and shouldn't copy if file already exists at destination" do
+      cmd = command
+      File.stub(exists?: true)
+      FileUtils.should_not_receive(:cp)
+      cmd.ui.should_receive(:error).with("File already exists: some/location/nodes.example.rb")
+      cmd.copy_template('some/location')
+    end
+  end
+
+  describe "#run" do
+    it "should copy example config to default location, if no location specified" do
+      cmd = command
+      cmd.should_receive(:copy_template).with(File.expand_path(Dir.pwd, File.join('nodes')))
+      cmd.run
+    end
+
+    it "should copy the example config to specified location" do
+      cmd = command
+      cmd.should_receive(:copy_template).with(File.expand_path("some/path"))
+      cmd.name_args << 'some/path'
+      cmd.run
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SousInit, *args)
+  end
+end
+

data/spec/lib/chef/knife/sous_list_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Chef::Knife::SousList do
+  include KnifeCommandHelpers
+
+  describe "#banner" do
+    it "should have display how to use command" do
+      command.banner.should == 'knife sous list'
+    end
+  end
+
+  describe "#run" do
+    it "should print out the list nodes" do
+      cmd = command
+      cmd.should_receive(:present_nodes)
+      cmd.run
+    end
+  end
+
+  describe "#present_nodes" do
+    it "should output presented nodes" do
+      cmd = command
+      cmd.config[:node_manifest_file] = 'spec/support/fixtures/nodes.rb'
+      cmd.ui.should_receive(:output).with("production node_awesome\nproduction web nodetastic\nvagrant\n")
+      cmd.present_nodes
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SousList, *args)
+  end
+end
+

data/spec/lib/chef/knife/sous_prepare_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Chef::Knife::SousPrepare do
+  include KnifeCommandHelpers
+
+  describe "#banner" do
+    it "should have display how to use command" do
+      command.banner.should == 'knife sous prepare [NAMESPACE] NODE'
+    end
+  end
+  it_should_behave_like "a node command" do
+    let(:node_command) { command }
+  end
+
+  describe "#solo_prepare_node" do
+    let(:node) { KnifeSous::Node.new('nodetastic') }
+    let(:cmd) { command }
+    let(:solo_prepare_command) { Chef::Knife::SoloPrepare.new }
+
+    before do
+      Chef::Knife::SoloPrepare.stub(new: solo_prepare_command)
+      solo_prepare_command.stub(:run)
+      cmd.stub(configure_command: solo_prepare_command)
+      node.update_config(
+        node_config: '/path/to/node/config',
+        hostname: 'host_ip'
+      )
+    end
+
+    it "should provide name to args and run" do
+      solo_prepare_command.should_receive(:run)
+      cmd.solo_prepare_node(node)
+
+      solo_prepare_command.name_args.should == %w[host_ip /path/to/node/config]
+    end
+  end
+
+  def command(*args)
+    knife_command(Chef::Knife::SousPrepare, *args)
+  end
+end
+

data/spec/lib/knife_sous/configure_command_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+class DummyCommand < Chef::Knife
+end
+
+describe KnifeSous::ConfigureCommand do
+  include KnifeCommandHelpers
+
+  describe "#configure_command" do
+    it "should be configured for a given node" do
+      node = KnifeSous::Node.new('some node',
+                                 foo: 'bar',
+                                 ssh_password: 'some_password')
+
+      cmd = command
+      KnifeSous::ConfigureCommand.configure_command(cmd, node)
+
+      cmd.config[:ssh_password].should == 'some_password'
+      cmd.config[:foo].should == 'bar'
+    end
+  end
+
+  def command(*args)
+    knife_command(DummyCommand, *args)
+  end
+end
+

data/spec/lib/knife_sous/dsl_definitions_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+class DummyClass
+  include KnifeSous::DSL
+end
+
+describe KnifeSous::DSL do
+  it_should_behave_like "a collection object" do
+    let(:collection) { DummyClass.new }
+  end
+
+  describe "#namespace" do
+    let(:some_block) { Proc.new { } }
+    let(:dummy_class) { DummyClass.new }
+
+    it "should instantiate a Namespace" do
+      namespace = KnifeSous::Namespace.new('stuff')
+      KnifeSous::Namespace.stub(new: namespace)
+      KnifeSous::Namespace.should_receive(:new).with('some name')
+      dummy_class.namespace('some name', &some_block)
+    end
+
+    it "should have the Namespace evaluate the passed in block" do
+      namespace = KnifeSous::Namespace.new('stuff')
+      KnifeSous::Namespace.stub(new: namespace)
+      namespace.should_receive(:evaluate_block).with(&some_block)
+      dummy_class.namespace('some name', &some_block)
+    end
+
+    it "should add the Namespace to the collection" do
+      dummy_class.namespace('some name', &some_block)
+      dummy_class.first.should be_a KnifeSous::Namespace
+    end
+  end
+
+  describe "#node" do
+    let(:dummy_class) { DummyClass.new }
+
+    it "should instantiate a Node" do
+      node = KnifeSous::Node.new('stuff')
+      KnifeSous::Node.stub(new: node)
+      KnifeSous::Node.should_receive(:new).with('some name', {config: 'stuff'})
+      dummy_class.node('some name', config: 'stuff' )
+    end
+
+    it "should add the Node to the collection" do
+      dummy_class.node('some name')
+      dummy_class.first.should be_a KnifeSous::Node
+    end
+  end
+end
+

data/spec/lib/knife_sous/dsl_wrapper_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+class DummyClass
+  include KnifeSous::DSLWrapper
+end
+
+describe KnifeSous::DSLWrapper do
+  it_should_behave_like "dsl wrapper" do
+    let(:klass) { DummyClass.new }
+  end
+end
+

data/spec/lib/knife_sous/mixins/hash_mixins_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe KnifeSous::HashMixins do
+
+  subject { KnifeSous::HashMixins }
+
+  describe "#sanitize_key"do
+    it "should return a lowercase, snake_case, symbol" do
+      subject.sanitize_key('SoMEthing-Ridic_uLous!').should == :something_ridic_ulous!
+    end
+  end
+
+  describe "#normalize_hash" do
+    it "should sanitize each key" do
+      subject.normalize_hash('GroS-key' => 'foo', OtherKey: 'bar').keys.should =~ [:gros_key, :otherkey]
+    end
+
+    it "should convert every value to string" do
+      subject.normalize_hash(number: 5, bar: 'baz').should == { number: '5', bar: 'baz' }
+    end
+  end
+end
+

data/spec/lib/knife_sous/namespace_presenter_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe KnifeSous::NamespacePresenter do
+  describe "#initialize" do
+    it "should keep track of the namespace" do
+      namespace = 'namespace'
+      KnifeSous::NamespacePresenter.new(namespace).namespace.should == 'namespace'
+    end
+  end
+
+  describe "#presenter" do
+    it "should return a NodePresenter if item is a Node" do
+      root_namespace_presenter = KnifeSous::NamespacePresenter.new('foo namespace')
+      some_node = KnifeSous::Node.new('some node')
+      root_namespace_presenter.presenter(some_node).should be_a KnifeSous::NodePresenter
+    end
+
+    it "should return a NamespacePresenter if item is a Namespace" do
+      root_namespace_presenter = KnifeSous::NamespacePresenter.new('foo namespace')
+      some_namespace = KnifeSous::Namespace.new('some node')
+      root_namespace_presenter.presenter(some_namespace).should be_a KnifeSous::NamespacePresenter
+    end
+  end
+
+  describe "#present" do
+    it "should present its own name" do
+      namespace = KnifeSous::Namespace.new("some namespace")
+      KnifeSous::NamespacePresenter.new(namespace).present.should == "some namespace"
+    end
+
+    it "should present each of its children" do
+      root_namespace = KnifeSous::Namespace.new("")
+      namespaceA = KnifeSous::Namespace.new(:namespace_a)
+      namespaceB = KnifeSous::Namespace.new(:namespace_b)
+
+      node1 = KnifeSous::Node.new(:node_1)
+      node2 = KnifeSous::Node.new(:node_2)
+      node3 = KnifeSous::Node.new(:node_3)
+      node4 = KnifeSous::Node.new(:node_4)
+
+      root_namespace << namespaceA
+      namespaceA << node1
+      namespaceA << node2
+      namespaceA << namespaceB
+      namespaceB << node3
+      root_namespace << node4
+
+      KnifeSous::NamespacePresenter.new(root_namespace).present.should ==<<-TEXT
+namespace_a node_1
+namespace_a node_2
+namespace_a namespace_b node_3
+node_4
+TEXT
+    end
+  end
+end
+

data/spec/lib/knife_sous/namespace_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe KnifeSous::Namespace do
+  let(:namespace) { KnifeSous::Namespace.new("some namespace name") }
+
+  it_should_behave_like "a collection object" do
+    let(:collection) { namespace }
+  end
+
+  it_should_behave_like "dsl wrapper" do
+    let(:klass) { namespace }
+  end
+
+  describe "#initialize" do
+    it "should set the name" do
+      KnifeSous::Namespace.new("some namespace name").name.should == 'some namespace name'
+    end
+
+    it "should convert symbols to strings" do
+      KnifeSous::Namespace.new(:foo_bar).name.should == 'foo_bar'
+    end
+  end
+
+  describe "root namespace" do
+    it "should instance_eval DSL from file" do
+      root_namespace = KnifeSous::Namespace.new('')
+      root_namespace.instance_eval do
+        namespace :production do |prod|
+          prod.node :node_awesome
+          prod.namespace :web do |web|
+            web.node :web_node
+          end
+        end
+        node :vagrant, node_config: 'nodes/some_node.json', ssh_config: 'vagrant config'
+      end
+
+      prod_namespace = root_namespace[0]
+      prod_namespace.should be_a KnifeSous::Namespace
+      prod_namespace.name.should == 'production'
+
+      vagrant_node = root_namespace[1]
+      vagrant_node.should be_a KnifeSous::Node
+      vagrant_node.name.should == 'vagrant'
+
+      node_awesome = prod_namespace[0]
+      node_awesome.should be_a KnifeSous::Node
+      node_awesome.name.should == 'node_awesome'
+
+      web_namespace = prod_namespace[1]
+      web_namespace.should be_a KnifeSous::Namespace
+      web_namespace.name.should == 'web'
+
+      web_node = web_namespace[0]
+      web_node.should be_a KnifeSous::Node
+      web_node.name.should == 'web_node'
+    end
+  end
+end
+

data/spec/lib/knife_sous/node_presenter_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe KnifeSous::NodePresenter do
+  describe "#initialize" do
+    it "should keep track of the node" do
+      node = 'node'
+      KnifeSous::NodePresenter.new(node).node.should == 'node'
+    end
+  end
+
+  describe "#present" do
+    it "should present the node name and a newline" do
+      node = KnifeSous::Node.new('Awesome node')
+      KnifeSous::NodePresenter.new(node).present.should == "Awesome node\n"
+    end
+  end
+end
+

data/spec/lib/knife_sous/node_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe KnifeSous::Node do
+  describe "#initialize" do
+    it "should set the name that was passed in" do
+      KnifeSous::Node.new('Node-Fuu').name.should == 'Node-Fuu'
+    end
+
+    it "should convert symbols to strings" do
+      KnifeSous::Node.new(:node_tastic).name.should == 'node_tastic'
+    end
+
+    it "should accept config arguments as a hash" do
+      options_hash = {ssh_config: 'stuff', other_something: 'foo' }
+      KnifeSous::Node.new(:node_tastic, options_hash).config.should == options_hash
+    end
+  end
+
+  describe "#node_name" do
+    it "should set the node name" do
+      node = KnifeSous::Node.new('some node', node_name: 'node_tastic')
+      node.node_name.should == 'node_tastic'
+    end
+
+    it "should default to the node name" do
+      node = KnifeSous::Node.new('some node')
+      node.node_name.should == 'some node'
+    end
+  end
+
+  describe "#update_config" do
+    it "should merge config options" do
+     node =  KnifeSous::Node.new(:node_tastic, foo: 'bar', baz: 'stuff')
+     node.update_config(baz: 'new stuff')
+     node.config.should == { foo: 'bar', baz: 'new stuff' }
+    end
+  end
+
+  describe "config hash" do
+    it "should sanitize hash keys" do
+      KnifeSous::Node.new(:node_tastic, 'fOO-BAr' => 'baz').config.keys.should =~ [:foo_bar]
+    end
+  end
+
+  describe "#method_missing" do
+    it "should try to access from config hash" do
+      KnifeSous::Node.new(:node_tastic, foo_bar: 'baz').foo_bar.should == 'baz'
+    end
+
+    it "should return nil if config doesn't exist" do
+      KnifeSous::Node.new(:node_tastic).foo_bar.should == nil
+    end
+  end
+
+  describe "#convert_aliases" do
+    it "should convert keys to their alias defined by #config_aliases" do
+      node = KnifeSous::Node.new(:foo)
+      node.stub(config_aliases: {foo: :bar})
+      node.convert_aliases(foo: 'baz').should == { bar: 'baz'}
+    end
+  end
+end
+