knife-hitori 0.0.1

data/lib/knife-hitori/resources/knife.erb

@@ -0,0 +1,34 @@
+current_dir = File.dirname(__FILE__)
+parent_dir = File.realdirpath(current_dir + '/..')
+chef_env_file = "#{parent_dir}/.chef_env"
+
+
+chef_env = (ENV['CHEF_ENV'] || (File.exists?(chef_env_file) && File.read(chef_env_file)) || 'dev').strip
+
+solo_environment                chef_env
+chef_solo_base_dir              parent_dir
+file_cache_path                 "#{chef_solo_base_dir}/.solo_cache"
+cookbook_path                   "#{chef_solo_base_dir}/cookbooks"
+
+data_bag_path_tpl               "#{chef_solo_base_dir}/data_bags/%s"
+data_bag_path                   sprintf(data_bag_path_tpl, chef_env)
+
+role_path                       "#{chef_solo_base_dir}/roles"
+
+encrypted_data_bag_secret_tpl   "#{data_bag_path_tpl}/crypt.key"
+encrypted_data_bag_secret       sprintf(encrypted_data_bag_secret_tpl, chef_env)
+
+settings_path_tpl               "#{chef_solo_base_dir}/environments/%s/settings.json"
+settings_path                   sprintf(settings_path_tpl, chef_env)
+
+
+
+Chef::Config[:solo] = true
+# load extra config
+config_files = %w(ec2.rb)
+
+config_files.each do |name|
+  filename = "#{current_dir}/#{name}"
+  Chef::Config.from_file(filename) if File.exists?(filename)
+end
+

data/lib/knife-hitori/resources/knife_ec2.erb

@@ -0,0 +1,14 @@
+knife[:availability_zone] = "<%= config[:availability_zone] %>"
+knife[:aws_access_key_id] = "<%= config[:aws_access_key_id] %>"
+knife[:aws_secret_access_key] = "<%= config[:aws_secret_access_key] %>"
+knife[:image] = "<%= config[:image] %>"
+knife[:flavor] = "<%= config[:flavor] %>"
+knife[:aws_ssh_key_id] = "<%= config[:aws_ssh_key_id] %>"
+knife[:ssh_port] = <%= config[:ssh_port] %>
+knife[:ssh_user] = "<%= config[:ssh_user] %>"
+knife[:identity_file] = "<%= config[:identity_file] %>"
+knife[:region] = "<%= config[:region] %>"
+knife[:template_file] = "<%= config[:template_file] %>"
+knife[:security_groups] = "<%= config[:security_groups] %>"
+knife[:remote_chef_dir] = "/tmp/chef-solo"
+

data/lib/knife-hitori.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+module KnifeHitori
+  def self.resource(name)
+    File.expand_path("knife-hitori/resources/#{name}", File.dirname(__FILE__))
+  end
+end

data/refs/Rakefile

@@ -0,0 +1,272 @@
+# coding: utf-8
+require 'rubygems'
+require 'rake'
+require 'erb'
+require 'digest/md5'
+
+DEFAULT_AZ = 'ap-northeast-1c'
+DEFAULT_AMI = 'ami-5d7dfa5c'
+DEFAULT_FLAVOR = 'm1.small'
+DEFAULT_REGION = 'ap-northeast-1'
+DEFAULT_BOOTSTRAP = 'centos_bootstrap.erb'
+
+
+THIS_DIR = File.absolute_path(File.dirname(__FILE__))
+CHEF_SOLO_DIR = "#{THIS_DIR}/chef-solo"
+TMPL_DIR = "#{THIS_DIR}/templates"
+
+KNIFE = "#{CHEF_SOLO_DIR}/.chef/knife.rb"
+EC2_CONFIG = "#{CHEF_SOLO_DIR}/.chef/ec2.rb"
+
+
+desc 'EC2関連の設定をknife.rbに追加する'
+task :ec2_config do
+  require 'chef/config'
+  template_ec2 = "#{TMPL_DIR}/knife_ec2.erb"
+  tmpl_ec2 = ERB.new(File.read(template_ec2))
+
+  Chef::Config.from_file(EC2_CONFIG) if File.exists?(EC2_CONFIG)
+  config = ask_ec2_config_all(Chef::Config.knife)
+
+  Dir.mkdir(File.dirname(EC2_CONFIG)) unless File.exists?(File.dirname(EC2_CONFIG))
+
+  open(EC2_CONFIG, 'w') do |f|
+    f.puts(tmpl_ec2.result(binding))
+  end
+end
+
+desc 'ec2.rb を削除する'
+task :clear_config do |t, args|
+  rm [EC2_CONFIG], :force => true
+end
+
+desc 'EC2サーバを新規に作成し、Chefを実行する'
+task :ec2_create_server do
+  tag_id = ec2_create_server_only
+  options = {RUN_TAG_KEY => "#{CHEF_EC2_TAG_ID}=#{tag_id}"}
+  ec2_provision(options)
+  info = fetch_server_info(options)
+  puts "Done! please access by 'ssh #{info.public_ip_address}'"
+end
+
+desc 'EC2サーバのリストを表示する'
+task :ec2_server_list do
+  cd CHEF_SOLO_DIR
+  sh "knife ec2 server list -c '#{KNIFE}'"
+end
+
+desc 'EC2サーバを起動する'
+task :ec2_create_server_only do |t, args|
+  ec2_create_server_only
+end
+
+desc 'EC2サーバ上でchefを実行する'
+task :ec2_provision do |t, _|
+  options = [RUN_GROUPS_KEY, RUN_TAG_KEY, RUN_IP_KEY, RUN_NAME_KEY].inject({}) {|t,x| t[x] = ENV[x].to_s if ENV[x]; t}
+
+  if options.size == 1
+    ec2_provision(options)
+  else
+    puts <<-EOM
+    Usage: rake #{t.name} [#{RUN_GROUPS_KEY}=<group>] [#{RUN_NAME_KEY}=<name>] [#{RUN_IP_KEY}=<public ip>] [#{RUN_TAG_KEY}=<tag-key>=<tag-value>]
+    please specify GROUP or NAME or IP or TAG
+
+
+    EOM
+    Rake::Task['ec2_server_list'].execute
+  end
+end
+
+#######################################################################################
+#######################################################################################
+#######################################################################################
+
+CHEF_EC2_TAG_ID = 'chefec2_id'
+RUN_GROUPS_KEY = 'GROUP'
+RUN_TAG_KEY    = 'TAG'
+RUN_IP_KEY     = 'IP'
+RUN_NAME_KEY   = 'NAME'
+
+
+def ask_ec2_config_all(knife, runtime=false)
+  config = {}
+  config[:availability_zone] = input_arg('availability_zone', knife[:availability_zone], ENV['EC2_AVAILABILITY_ZONE'], DEFAULT_AZ)
+  config[:aws_access_key_id] = input_arg('aws_access_key_id', knife[:aws_access_key_id], ENV['AWS_ACCESS_KEY_ID']) unless runtime
+  config[:aws_secret_access_key] = input_arg('aws_secret_access_key', knife[:aws_secret_access_key], ENV['AWS_SECRET_ACCESS_KEY']) unless runtime
+  config[:image] = input_arg('ami image', knife[:image], ENV['EC2_AMI_IMAGE'], DEFAULT_AMI)
+  config[:flavor] = input_arg('flavor', knife[:flavor], ENV['EC2_FLAVOR'], DEFAULT_FLAVOR)
+  config[:groups] = input_arg('Security Group', knife[:groups], ENV['EC2_SECURITY_GROUP'], 'default')
+  config[:ssh_user] = input_arg('ssh_user', knife[:ssh_user], ENV['EC2_SSH_USER'], 'ec2-user')
+  config[:identity_file] = k = input_arg('identity_file(*.pem)', knife[:identity_file], ENV['EC2_PRIVATE_KEY'])
+  config[:ssh_key] = input_arg('ssh_key_name', knife[:ssh_key], ENV['EC2_SSH_KEY'], File.basename(k || '').sub(/\.pem$/, ''))
+  config[:region] = input_arg('region', knife[:region], ENV['EC2_REGION'], DEFAULT_REGION)
+  config[:template_file] = input_arg('bootstrap template', knife[:template_file], "#{TMPL_DIR}/#{DEFAULT_BOOTSTRAP}")
+  config[:identity_file] = File.absolute_path(config[:identity_file]) if config[:identity_file]
+  config
+end
+
+def input_arg(message, *defaults)
+  default = defaults.select { |x| !x.to_s.empty? }.first
+  while true
+    print "#{message} [#{default}] ? "
+    input = STDIN.gets.chomp
+    input = input.empty? ? default : input
+    break if not block_given? or yield(input)
+  end
+  input
+end
+
+def create_random_id
+  Digest::MD5.hexdigest(Time.new.to_i.to_s + rand.to_s)
+end
+
+def configure_chef
+  require 'chef/config'
+  Chef::Config.from_file(KNIFE)
+end
+
+def server_info_list
+  require 'fog'
+  configure_chef
+  connection = Fog::Compute.new(
+      :provider => 'AWS',
+      :aws_access_key_id => Chef::Config[:knife][:aws_access_key_id],
+      :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
+      :region => Chef::Config[:knife][:region]
+  )
+  connection.servers.all.to_a
+end
+
+def ec2_create_server_only
+  configure_chef
+  knife = Chef::Config.knife
+  config = ask_ec2_config_all(knife, true)
+  tag_id = create_random_id
+
+  cd CHEF_SOLO_DIR
+  cmd_list = %w(knife ec2 server create)
+  cmd_list << "-c '#{KNIFE}'"
+  cmd_list << "-T #{CHEF_EC2_TAG_ID}=#{tag_id}"
+  add_args(cmd_list, '--groups=', :groups, knife, config)
+  add_args(cmd_list, '--availability-zone=', :availability_zone, knife, config)
+  add_args(cmd_list, '--image=', :image, knife, config, true)
+  add_args(cmd_list, '--flavor=', :flavor, knife, config)
+  add_args(cmd_list, '--ssh-user=', :ssh_user, knife, config, true)
+  add_args(cmd_list, '--identity-file=', :identity_file, knife, config, true)
+  add_args(cmd_list, '--ssh-key=', :ssh_key, knife, config, true)
+  add_args(cmd_list, '--region=', :region, knife, config)
+  add_args(cmd_list, '--template-file=', :template_file, knife, config, true)
+  sh cmd_list.join(' ')
+  return tag_id
+end
+
+def add_args(cmd_list, tmpl, key, orig, update, force=false)
+  cmd_list << (tmpl + update[key]) if force or orig[key] != update[key]
+end
+
+def fetch_server_info(options)
+  require 'set'
+  servers = server_info_list
+
+  if options[RUN_TAG_KEY]
+    tag_key, tag_value = options[RUN_TAG_KEY].to_s.split(/=/, 2)
+    servers.select {|x| x.tags[tag_key] == tag_value.to_s}
+  elsif options[RUN_GROUPS_KEY]
+    g = Set.new(options[RUN_GROUPS_KEY].split(/,/))
+    servers.select {|x| (Set.new(x.groups) & g).size > 0}
+  elsif options[RUN_NAME_KEY]
+    servers.select {|x| x.tags['Name'] == options[RUN_NAME_KEY]}
+  elsif options[RUN_IP_KEY]
+    servers.select {|x| x.public_ip_address == options[RUN_IP_KEY]}
+  end
+end
+
+def console_log(text, color=nil)
+  #Background colors
+  #40	Black
+  #41	Red
+  #42	Green
+  #43	Yellow
+  #44	Blue
+  #45	Magenta
+  #46	Cyan
+  #47	White
+  c = 47 - ((color.to_i + 3) % 7)
+  print "\e[#{c}m#{text}\e[0m"
+end
+
+def exec_remote(server, knife, command, options)
+  require 'net/ssh'
+  Net::SSH.start(server.public_ip_address, knife[:ssh_user], :keys => [knife[:identity_file]]) do |ssh|
+    ssh.open_channel do |ch|
+      ch.request_pty do |pty, success|
+        raise 'Could not obtain pty' unless success
+      end
+      ch.exec(command) do |c, success|
+        abort 'could not execute command' unless success
+        ch.on_data do |c, data|
+          console_log(data, options[:idx])
+        end
+
+        ch.on_extended_data do |c, type, data|
+          console_log(data, options[:idx])
+        end
+      end
+    end
+  end
+end
+
+def run_ec2_provision(knife, server, options)
+  require 'net/scp'
+  mkdir_cmd = <<-EOS
+     [ -e #{knife[:remote_chef_dir]} ] && sudo rm -rf #{knife[:remote_chef_dir]}
+     sudo mkdir -p #{knife[:remote_chef_dir]}
+     sudo chmod 777 #{knife[:remote_chef_dir]}
+  EOS
+  exec_remote(server, knife, mkdir_cmd, options)
+
+  console_log "Uploading Chef Cookbooks to #{server.public_ip_address}\n", options[:idx]
+  Net::SCP.start(server.public_ip_address, knife[:ssh_user], :keys => [knife[:identity_file]], :compression => true) do |scp|
+    scp.upload!(CHEF_SOLO_DIR, knife[:remote_chef_dir], :recursive => true, :verbose => true)
+  end
+  console_log "Upload is done #{server.public_ip_address}\n", options[:idx]
+
+  remote_dir = "#{knife[:remote_chef_dir]}/#{File.basename(CHEF_SOLO_DIR)}"
+  chef_solo = 'do_cook.sh'
+  script = <<-EOS
+    tr -d '\\r' < #{remote_dir}/#{chef_solo} > #{remote_dir}/.a; mv #{remote_dir}/.a #{remote_dir}/#{chef_solo}
+    sudo CHEF_ENV=#{ENV['CHEF_ENV']} CHEF_ROLE=#{ENV['CHEF_ROLE']} sh #{remote_dir}/#{chef_solo} #{ENV['chef_option']}
+  EOS
+  exec_remote(server, knife, script, options)
+end
+
+def find_ec2_servers(options)
+  server = nil
+  3.times do
+    server = fetch_server_info(options)
+    break if server && !server.empty?
+    sleep 5
+  end
+  server
+end
+
+def ec2_provision(options)
+  configure_chef
+  servers = find_ec2_servers(options)
+  unless servers && !servers.empty?
+    puts "no server found(#{options})"
+    return
+  end
+
+  threads = []
+  servers.each_with_index do |server, idx|
+    threads << Thread.new {
+      # p server.public_ip_address
+      run_ec2_provision(Chef::Config.knife, server, :idx => idx)
+    }
+  end
+  threads.each do |t|
+    t.join
+  end
+end
+

data/refs/Vagrantfile

@@ -0,0 +1,54 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+require 'json'
+
+CHEF_ENV = (ENV['CHEF_ENV'] || (File.exists?(chef_env_file) && File.read(chef_env_file)) || 'dev').strip
+
+Vagrant::Config.run do |config|
+  config.vm.define :sample do |c|   # CHANGE_THIS!   :sample は vagrant up sample  のときの名前になります。
+    # box_urlと紐付けられる名前を付けましょう
+    c.vm.box = "cent64-chef11"                                            # CHANGE_THIS!
+    
+    # ImageのURLを指定しましょう。一旦関連付けられるとLocalにCacheされます。
+    c.vm.box_url = 'http://developer.nrel.gov/downloads/vagrant-boxes/CentOS-6.4-x86_64-v20130309.box' # CHANGE_THIS!
+
+    # VirtualBoxのホストOSからゲストOSへアクセスするときのIPアドレス。重複するようなら変更してください。  # CHANGE_THIS!
+    c.vm.network :hostonly, '192.168.33.10'
+    
+    # NAT の設定をするならば設定してください
+    # c.vm.forward_port 80, 8080
+
+    # 共有フォルダ設定
+    #                        Share-Name     Guest-PATH       Host-Path
+    config.vm.share_folder  'sprocket', '/var/lib/sprocket', '..'
+  end
+
+  config.vm.provision :chef_solo do |chef|
+    chef.cookbooks_path = './chef-solo/cookbooks'
+    chef.roles_path = './chef-solo/roles'
+    chef.data_bags_path = "./chef-solo/data_bags/#{CHEF_ENV}"
+    # node.json を読み込んで設定
+    settings_json = "./chef-solo/environments/#{CHEF_ENV}/settings.json"
+    if File.exists?(settings_json)
+        json_data = JSON.parse(File.read(settings_json))
+        if json_data['run_list']
+            json_data['run_list'].each do |cmd|
+                if cmd =~ /^role\[(.+)\]/
+                    chef.add_role $1
+                elsif cmd =~ /^recipe\[(.+)\]/
+                    chef.add_recipe $1
+                end
+            end
+        end
+
+        if ENV['CHEF_ROLE']
+          chef.add_role ENV['CHEF_ROLE']
+          json_data['run_list'] << "role[#{ENV['CHEF_ROLE']}]"
+        end
+
+        chef.json = json_data
+    end
+  end
+
+end

data/refs/run_chef_solo.sh

@@ -0,0 +1,41 @@
+#!/bin/sh
+# run_chef_solo.sh
+
+set -e -a
+
+THIS_DIR=$(cd $(dirname $0); pwd)
+
+if [ -z "$CHEF_ENV" -a -e ${THIS_DIR}/.chef_env ]; then
+    CHEF_ENV=$(cat ${THIS_DIR}/.chef_env)
+else
+    CHEF_ENV=${CHEF_ENV:-dev}
+fi
+
+cd $THIS_DIR
+
+CHEF_SOLO_DIR=$THIS_DIR
+SOLO=${CHEF_SOLO_DIR}/.chef/knife.rb
+RBENV_FILE=${RBENV_FILE:-/usr/local/share/rbenv.sh}
+RUNLIST_FILE=${CHEF_SOLO_DIR}/run_list/${CHEF_ENV}/`hostname`
+SERVER_JSON=${CHEF_SOLO_DIR}/environments/${CHEF_ENV}/settings.json
+
+if [ ! -e $SERVER_JSON -a -e ${CHEF_SOLO_DIR}/node.json ]; then
+    SERVER_JSON=${CHEF_SOLO_DIR}/node.json
+fi
+
+OPTIONS=""
+if [ "$#" -gt 0 ]; then
+    OPTIONS="$@"
+elif [ -e $RUNLIST_FILE ]; then
+    OPTIONS="-o $(cat $RUNLIST_FILE)"
+elif [ -n "$CHEF_ROLE" ]; then
+    OPTIONS="-o role[${CHEF_ROLE}]"
+fi
+
+# enable rbenv and chef
+if [ -e $RBENV_FILE ]; then
+    . $RBENV_FILE
+fi
+
+echo chef-solo -c $SOLO -j $SERVER_JSON $OPTIONS
+chef-solo -c $SOLO -j $SERVER_JSON $OPTIONS

data/refs/util/create_encrypt_databag.rb

@@ -0,0 +1,57 @@
+# coding: utf-8
+
+require 'rubygems'
+require 'chef'
+require 'chef/knife'
+require 'chef/encrypted_data_bag_item'
+require 'json'
+require 'fileutils'
+require 'optparse'
+
+
+options = {}
+opt = OptionParser.new
+# opt.on("-k SecretKey") {|v| options[:key] = v}
+opt.on('-j JSON') {|v| options[:data] = v}
+opt.on('-b BagName') {|v| options[:bag] = v}
+opt.on('-i ItemName') {|v| options[:item] = v}
+opt.on('--show') {|_| options[:show] = true}
+opt.permute!(ARGV)
+
+unless (options[:data] or options[:show]) and options[:bag] and options[:item]
+  puts opt.help
+  exit
+end
+
+class Fixnum
+  def to_json(options = nil)
+    to_s
+  end
+end
+
+knife = Chef::Knife.new
+knife.configure_chef
+
+# http://lists.opscode.com/sympa/arc/chef/2012-11/msg00402.html
+
+Chef::Config[:solo] = true
+data_bag_path = Chef::Config[:data_bag_path]
+secret = Chef::EncryptedDataBagItem.load_secret(Chef::Config[:encrypted_data_bag_secret])
+
+if options[:show]
+  spr_creds = Chef::EncryptedDataBagItem.load(options[:bag], options[:item], secret)
+  puts JSON.pretty_generate(spr_creds.to_hash)
+else
+  data = nil
+  File.open(options[:data], "r") do |f|
+    data = JSON.parse(f.read)
+  end
+
+  encrypted_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(data, secret)
+
+  bag_dir = "#{data_bag_path}/#{options[:bag]}"
+  FileUtils.mkpath(bag_dir)
+  File.open("#{bag_dir}/#{options[:item]}.json", 'w') do |f|
+    f.print encrypted_data.to_json
+  end
+end

data/refs/util/crypt_file.rb

@@ -0,0 +1,45 @@
+
+require 'rubygems'
+require 'chef'
+require 'chef/knife'
+require 'chef/encrypted_data_bag_item'
+require 'json'
+require 'optparse'
+require_relative '../cookbooks/cryptfile/libraries/crypt_util'
+
+
+options = {}
+opt = OptionParser.new
+opt.on('-i input_file') {|v| options[:input_file] = v}
+opt.on('-d') {|_| options[:mode] = :decrypt}
+opt.on('-e') {|_| options[:mode] = :encrypt}
+opt.on('-k secret_file') {|v| options[:secret_file] = v}
+opt.permute!(ARGV)
+
+unless options[:input_file] and options[:mode]
+  puts opt.help
+  exit
+end
+
+class Fixnum
+  def to_json(options = nil)
+    to_s
+  end
+end
+
+knife = Chef::Knife.new
+knife.configure_chef
+Chef::Config[:solo] = true
+
+# http://lists.opscode.com/sympa/arc/chef/2012-11/msg00402.html
+
+secret_file = options[:secret_file] || Chef::Config[:encrypted_data_bag_secret]
+secret = File.read(secret_file)
+data = File.read(options[:input_file])
+
+case options[:mode]
+  when :encrypt
+    print JSON.dump(encrypt(data, secret))
+  when :decrypt
+    print decrypt(JSON.parse(data), secret)
+end

data/spec/knife/hitori_config_spec.rb

@@ -0,0 +1,106 @@
+# coding: utf-8
+
+require 'fileutils'
+
+require 'spec_helper'
+
+require 'chef/knife/hitori_config'
+
+
+describe 'hitori_config' do
+  before do
+    Chef::Knife::HitoriConfig.load_deps
+    @obj = Chef::Knife::HitoriConfig.new
+    setup_interactive_response
+  end
+
+  def setup_interactive_response
+    @obj.stub(:input_arg) { |message, args|
+      case message
+        when /availability_zone/ then
+          'MY_AZ'
+        when /aws_access_key_id/ then
+          'MY_access_key'
+        when /aws_secret_access_key/ then
+          'MY_secret'
+        when /ami image/ then
+          'MY_ami'
+        when /flavor/ then
+          'MY_flavor'
+        when /Security Group/ then
+          'MY_group'
+        when /ssh_user/ then
+          'MY_user'
+        when /identity_file/ then
+          'MY_identity.pem'
+        when /ssh_key_name/ then
+          'MY_ssh_key_name'
+        when /region/ then
+          'MY_region'
+        when /overwrite knife/ then
+          (@obj.config[:yes] || 'Y')
+      end
+    }
+  end
+
+  describe :run do
+    def knife_ruby_path
+      "#{@temp_dir}/.chef/knife.rb"
+    end
+
+    def knife_ec2_ruby_path
+      "#{@temp_dir}/.chef/ec2.rb"
+    end
+
+    before do
+      @temp_dir = Dir.mktmpdir
+      @obj.config[:base_dir] = @temp_dir
+    end
+
+    after do
+      FileUtils.remove_entry_secure(@temp_dir)
+    end
+
+    context 'brand new' do
+      it 'should not call input_arg for overwrite knife.rb' do
+        @obj.should_not_receive(:input_arg).with(/overwrite knife.rb/, 'N')
+        @obj.run
+      end
+
+      it 'should create knife.rb' do
+        @obj.run
+        ::File.exists?(knife_ruby_path).should be_true
+      end
+
+      it 'should create ec2.rb' do
+        @obj.run
+        ::File.exists?(knife_ec2_ruby_path).should be_true
+      end
+    end
+
+    context 'knife.rb exists already' do
+      before do
+        @content = 'knife[:fruit] = "apple"'
+        FileUtils.makedirs(::File.dirname(knife_ruby_path))
+        ::File.write(knife_ruby_path, @content)
+      end
+
+      it 'should call input_arg for overwrite knife.rb' do
+        @obj.should_receive(:input_arg).with(/overwrite knife.rb/, 'N')
+        @obj.run
+      end
+
+      it 'should overwrite if user input y' do
+        @obj.config[:yes] = 'y'
+        @obj.run
+        ::File.read(knife_ruby_path).should_not == @content
+      end
+
+      it 'should not overwrite if user input n' do
+        @obj.config[:yes] = 'n'
+        @obj.run
+        ::File.read(knife_ruby_path).should == @content
+      end
+    end
+  end
+end