brocadesan 0.4.0

data/test/device_test.rb

@@ -0,0 +1,203 @@
+require 'brocadesan'
+require 'minitest/autorun'
+require 'output_helpers'
+
+class DeviceTest < MiniTest::Test
+  include SshStoryWriter
+  include Mock::Net::SSH
+  patch_revert
+  
+  def setup
+    @device = TestDevice.new("test","test","test")
+    #Net::SSH::set_error ""
+  end
+  
+  def test_device_setup
+    assert_instance_of TestDevice, @device
+  end
+  
+  def test_prompt
+    assert_equal @device.prompt, TestDevice::DEFAULT_QUERY_PROMPT
+    @new_device = TestDevice.new("test","test","test",:prompt => "$ ")
+    assert_equal @new_device.prompt, "$ "
+  end
+  
+  def test_get_mode
+    @device.instance_variable_set(:@opts,{:interactive=>true})
+    assert_equal "interactive", @device.get_mode
+    
+    @device = TestDevice.new("test","test","test", :interactive=>true)
+    assert_equal "interactive", @device.get_mode
+    
+    @device.set_mode("script")
+    assert_equal "script", @device.get_mode
+  end
+  
+  def test_set_mode
+    assert_equal "interactive", @device.set_mode("interactive")
+    
+    assert_equal "interactive", @device.set_mode(:interactive)
+    
+    assert_equal "script", @device.set_mode("script")
+    
+    assert_equal "script", @device.set_mode(:script)
+    
+    assert_equal "script", @device.set_mode("blabla")
+  end
+
+  def test_session
+    #stub start with test connection coming from net/ssh/test
+    Net::SSH.stub :start, connection do
+      @device.session do 
+        assert_instance_of Net::SSH::Connection::Session, @device.instance_variable_get(:@session)
+        assert_equal 1, @device.instance_variable_get(:@session_level)
+        @device.session do
+          assert_equal 2, @device.instance_variable_get(:@session_level)
+        end
+        refute @device.instance_variable_get(:@session).closed?
+        assert_equal 1, @device.instance_variable_get(:@session_level)
+      end
+    end
+    assert @device.instance_variable_get(:@session).closed?
+    
+    # session can we called only with block, raises error otherwise
+    exp = assert_raises(TestDevice::Error) do
+      @device.session
+    end
+  end
+  
+  def test_script_mode
+    #stub start with test connection coming from net/ssh/test
+    @device.set_mode :interactive
+    assert_equal "interactive", @device.get_mode
+    Net::SSH.stub :start, connection do
+      @device.script_mode do 
+        assert_equal "script", @device.get_mode
+      end
+    end
+    assert_equal "interactive", @device.get_mode
+    
+    # this can we called only with block, raises error otherwise
+    exp = assert_raises(LocalJumpError) do
+      @device.script_mode
+    end
+  end
+  
+   def test_interactive_mode
+    #stub start with test connection coming from net/ssh/test
+    @device.set_mode :script
+    assert_equal "script", @device.get_mode
+    Net::SSH.stub :start, connection do
+      @device.interactive_mode do 
+        assert_equal "interactive", @device.get_mode
+      end
+    end
+    assert_equal "script", @device.get_mode
+    
+    # this can we called only with block, raises error otherwise
+    exp = assert_raises(LocalJumpError) do
+      @device.interactive_mode
+    end
+  end
+  
+  def test_query_in_session
+    cmds = ["test"]
+    exp_response = write_non_interactive_story(cmds,["test_ok"],TestDevice::DEFAULT_QUERY_PROMPT)
+    Net::SSH.stub :start, connection do
+      @device.session do 
+        response=@device.query(cmds[0])
+        assert_instance_of TestDevice::Response, response
+        assert_equal exp_response, response.data
+      end
+    end
+  end
+  
+  def test_interactive_query
+    cmds = ["cfgsave","y"]
+    replies = ["confirm? [y,n]"]
+    exp_response = write_interactive_story(cmds,replies,TestDevice::DEFAULT_QUERY_PROMPT)
+    
+    @device.set_mode("interactive")
+    # connection is net/ssh/test method
+    @device.instance_variable_set(:@session,connection)
+    
+    response=nil
+    assert_scripted do
+
+      response=@device.query("cfgsave","y")
+      
+      assert_equal exp_response, response.data
+    end    
+    assert_instance_of TestDevice::Response, response
+    
+    # response safety net test for infinite newline response
+    # create story with 150 newline commands
+    cmds = Array.new(150, "")
+    replies = Array.new(150,"confirm? [y,n]")
+    exp_response = write_interactive_story(cmds,replies,TestDevice::DEFAULT_QUERY_PROMPT)
+    
+    
+    # this is pure hack, this raises RuntimeError as the connection script is expecting 150 responses
+    # but there are only 100 if them as expected
+    # since the script did not match reality we had to assume this worked
+    # we do not get any response so we cannot check it precisly
+    # but we at least check the internal retries value
+    # not the best test but so far the best I came up with
+    
+    assert_raises RuntimeError do
+      # story contains 150 new line responses
+      # this closses the channel after 100
+      @device.query("")
+    end
+        
+    assert_equal 100, @device.instance_variable_get(:@retries)
+  end
+
+  def test_non_interactive_query
+    cmds = ["cfgshow","switchshow"]
+    replies = ["not_available","is_available"]
+    error = "cannot execute this"
+    # write non itneractive ssh story that should play out when running the query
+    exp_response = write_non_interactive_story(cmds,replies,TestDevice::DEFAULT_QUERY_PROMPT)
+    
+    # connection is net/ssh/test method
+    @device.instance_variable_set(:@session,connection)
+    response=nil
+    assert_scripted do
+
+      response=@device.query(*cmds)
+      
+      assert_equal exp_response, response.data
+    end
+    assert_instance_of TestDevice::Response, response
+    
+    #errors
+    # write story endig with error
+    exp_response = write_failed_simple_story(cmds[0],error,TestDevice::DEFAULT_QUERY_PROMPT)
+    exp = assert_raises TestDevice::Error do 
+      @device.query(cmds[0])
+    end
+    assert_equal "#{error}\n", exp.message
+  end
+end
+
+class ResponseTest < MiniTest::Test
+  def setup
+    @response = TestDevice::Response.new("> ")
+  end
+  
+  def test_parse
+    #parse should end with end
+    @response.parsed="test"
+    @response.parse
+    assert_equal a={:parsing_position=>"end"},  @response.parsed
+  end
+  
+  def test_prompt
+    assert_equal @response.instance_variable_get(:@prompt), "> "
+  end
+end
+
+class TestDevice
+  include SshDevice
+end

data/test/output_helpers.rb

@@ -0,0 +1,308 @@
+require 'yaml'
+require 'net/ssh/test'
+
+module OutputReader
+  
+  attr_accessor :output_dir
+  
+  def read_all_starting_with(regexp,&block)
+    @output_dir=Dir.pwd if @output_dir.nil?
+    files=Dir.glob(File.join(@output_dir,"#{regexp}*.txt"))
+    files.each do |f|
+      contents = File.read(f)
+      yield f, contents
+    end
+  end
+  
+  def read_yaml_for(file)
+    parts=file.split(".")
+    file_name=parts[0..-2].join(".")
+    YAML.load(File.read("#{file_name}.yml"))
+  end
+  
+  def new_mock_response
+    Brocade::SAN::Switch::Response.new("> ")
+  end
+end
+
+# this is used to check the _exec methods in device
+# for the remaining test see the below monkeypath mock 
+module SshStoryWriter
+  include Net::SSH::Test
+  
+  # creates a interactive ssh story for testing and returns expeced response for that story
+  def write_interactive_story(cmds,partial_replies,prompt="")
+    cmd=cmds.shift
+    response = "#{prompt}"
+    story do |session|
+      channel = session.opens_channel
+      channel.sends_request_pty
+      channel.sends_exec cmd
+      response +="#{cmd}\n"
+      partial_replies.each_with_index do |pr,i|
+        channel.gets_data pr
+        channel.sends_data "#{cmds[i]}\n"
+        
+        response +="#{pr}"
+        response +="#{cmds[i]}\n"
+      end
+      channel.gets_close
+      channel.sends_close
+    end
+    
+    return response
+  end
+  
+  # creates non interactive ssh story for testing and returns expeced response for that story
+  def write_non_interactive_story(cmds,replies,prompt="")
+    response = ""
+    story do |session|
+      replies.each_with_index do |reply,i|
+        channel = session.opens_channel
+        channel.sends_exec cmds[i]
+        channel.gets_data reply
+        channel.gets_close
+        channel.sends_close
+        response +="#{prompt}#{cmds[i]}\n"
+        response +="#{reply}\n"
+      end
+
+    end
+    
+    return response
+  end
+  
+  def write_failed_simple_story(cmd,error,prompt="")
+    response = ""
+    story do |session|
+      channel = session.opens_channel
+      channel.sends_exec cmd
+      channel.gets_extended_data error
+      #session.gets_channel_extended_data(channel, error)
+      channel.gets_close
+      channel.sends_close
+      response +="#{prompt}#{cmd}\n"
+      #response +="#{reply}\n"
+
+    end
+    
+    return response
+  end
+end
+
+# patch for request_pry based on https://github.com/test-kitchen/test-kitchen/blob/master/spec/kitchen/ssh_spec.rb#L86-L113
+module Net
+
+  module SSH
+
+    module Test
+
+      class Channel
+
+        def sends_request_pty
+          pty_data = ["xterm", 80, 24, 640, 480, "\0"]
+
+          script.events << Class.new(Net::SSH::Test::LocalPacket) do
+            def types
+              if @type == 98 && @data[1] == "pty-req"
+                @types ||= [
+                  :long, :string, :bool, :string,
+                  :long, :long, :long, :long, :string
+                ]
+              else
+                super
+              end
+            end
+          end.new(:channel_request, remote_id, "pty-req", false, *pty_data)
+        end
+      end
+    end
+  end
+end
+
+# simplified mock module that is used to monkey patch/stub Net::SSH.start
+# the stubed method resturns mocked Session
+# the session for now response to exec!, closed? and close
+# which is sufficient for my testing
+# Usage:
+# put following into subclasees MiniTest::Test that should use this mock
+#  include Mock::Net::SSH
+#  patch_set
+#
+# or
+#
+# put following into subclasees MiniTest::Test that should not use this mock
+# mention this explicitely as some other test might have set it
+#  include Mock::Net::SSH
+#  patch_revert
+#
+module Mock
+module Net
+module SSH
+  
+  def self.included(base)
+    base.extend(ClassMethods)  
+  end
+  
+  def initialize(*args)
+     patch_configure
+     super(*args)     
+  end
+  
+  def patch_configure;  end
+        
+  module ClassMethods
+    def patch_set
+      alias_method :patch_configure, :monkey_patch
+    end
+    
+    def patch_revert
+      alias_method :patch_configure, :monkey_patch_revert
+    end
+  end
+  
+  @@data="Response"
+  @@error=""
+  @@channel="channel"
+  
+  def self.get_data
+    @@data
+  end
+  
+  def self.get_error
+    @@error
+  end
+  
+  def self.get_channel
+    @@channel
+  end
+
+  def self.set_data(x)
+    @@data=x
+  end
+  
+  def self.set_error(x)
+    @@error=x
+  end
+  
+  def self.set_channel(x)
+    @@channel=x
+  end
+  
+  class Session 
+    def exec!(command, &block)
+      @data=Mock::Net::SSH::get_data.dup
+      @error=Mock::Net::SSH::get_error.dup
+      @ch=Mock::Net::SSH::get_channel.dup
+      
+      if block
+        block.call(@ch, :stdout, @data)
+        block.call(@ch, :stderr, @error)
+      else
+        $stdout.print(data)
+      end
+    end
+      
+    def close
+      @closed=true
+    end
+    
+    def closed?
+      @closed.nil? ? false : @closed
+    end
+  end
+  
+  private
+  def monkey_patch
+    ::Net::SSH.instance_eval do
+      singleton = self.singleton_class
+      if !singleton.respond_to? :old_start 
+        singleton.send(:alias_method, :old_start, :start)
+      
+        def self.start(host, user, options={}, &block)  
+          if block
+            yield Mock::Net::SSH::Session.new
+          else
+            return Mock::Net::SSH::Session.new
+          end
+        end
+      end
+    end    
+  end
+  
+  def monkey_patch_revert
+    ::Net::SSH.instance_eval do
+      if self.singleton_class.respond_to? :old_start
+        self.singleton_class.send(:alias_method, :start, :old_start)
+        self.singleton_class.send(:undef_method, :old_start)
+      end
+    end    
+  end
+end
+end
+end
+
+module Kernel
+  # stubs query method by another method that assiges the parameters to @test_string and runing original query
+  def query_stub(&block)
+   self.instance_eval do
+      self.singleton_class.send(:alias_method, :old_query, :query)
+      @query_string=""
+      def query(*cmds)
+        @query_string||=""
+        @query_string<<cmds.join(",")
+        old_query(*cmds)
+      end
+    end
+    yield
+    self.instance_eval do 
+      self.singleton_class.send(:alias_method, :query, :old_query)
+      self.singleton_class.send(:undef_method, :old_query)
+    end  
+  end
+  
+  # stubs query method by another method that assiges the parameters to @test_string and runing original query
+  def abort_transaction_stub(&block)
+   self.instance_eval do
+      self.singleton_class.send(:alias_method, :old_abort_transaction, :abort_transaction)
+      def abort_transaction
+        @trans_aborted=true
+        old_abort_transaction
+      end
+    end
+    yield
+    self.instance_eval do 
+      self.singleton_class.send(:alias_method, :abort_transaction, :old_abort_transaction)
+      self.singleton_class.send(:undef_method, :old_abort_transaction)
+    end  
+  end
+  
+  # stubs query method by another method that assiges the parameters to @test_string and runing original query
+  def raise_if_obj_do_not_exist_stub(&block)
+   self.instance_eval do
+      self.singleton_class.send(:alias_method, :old_raise_if_obj_do_not_exist, :raise_if_obj_do_not_exist)
+      def raise_if_obj_do_not_exist(obj)
+        if !@run.nil?
+          old_raise_if_obj_do_not_exist(obj)
+        end
+        @run=true
+      end
+    end
+    yield
+    self.instance_eval do 
+      self.singleton_class.send(:alias_method, :raise_if_obj_do_not_exist, :old_raise_if_obj_do_not_exist)
+      self.singleton_class.send(:undef_method, :old_raise_if_obj_do_not_exist)
+    end  
+  end
+  
+  def multistub(cmds,&block)
+    if !cmds.empty?
+      cmd = cmds.shift
+      stub cmd[0], cmd[1] do
+          multistub cmds, &block        
+      end
+    else
+      yield
+    end
+  end
+end