merged cont.
[opensuse:yast-rest-service.git] / webservice / test / functional / lib_session_test.rb
1 # Source: http://www.codeforpeople.com/lib/ruby/session/session-2.4.0/test/session.rb
2 #
3 # Pulled from http://www.codeforpeople.com/lib/ruby/session/session-2.4.0/test/session.rb
4 # License: Ruby (http://www.ruby-lang.org/en/LICENSE.txt)
5
6 require File.dirname(__FILE__) + '/../test_helper'
7
8 class LibSessionTest < ActiveSupport::TestCase
9
10
11   require 'session'
12
13   $VERBOSE=nil
14   STDOUT.sync = true
15   STDERR.sync = true
16   STDOUT.puts "Session::VERSION <#{ Session::VERSION }>"
17   STDOUT.puts "Session.use_spawn <#{ Session.use_spawn ? 'true' : 'false' }>"
18   STDOUT.puts "Session.use_open3 <#{ Session.use_open3 ? 'true' : 'false' }>"
19   Session::debug = true
20
21   #
22   # a timeout method which does not stop all threads!
23   # for testing only!
24   #
25   class TimeoutError < StandardError; end
26   def timeout n
27     #{{{
28     ret = nil
29     cid = fork 
30     unless cid
31       trap('SIGQUIT'){ exit! }
32       sleep n
33       begin; Process.kill 'SIGUSR1', Process.ppid; rescue Errno::Exception; end 
34       exit!
35     else
36       begin
37         handler = trap('SIGUSR1'){throw :timeout, TimeoutError.new}
38         thrown = catch(:timeout){ ret = yield }
39         if TimeoutError === thrown
40           display
41           STDIN.gets
42           raise thrown
43         end
44       ensure
45         begin; Process.kill 'SIGQUIT', cid; rescue Exception; end 
46         begin; Process.wait; rescue Exception => e; end
47         trap 'SIGUSR1', handler if defined? handler
48       end
49     end
50     ret
51     #}}}
52     end
53     
54   def display
55     #{{{
56     puts "$session_command        < #{ $session_command.inspect }> "
57     puts "$session_iodat          < #{ $session_iodat.inspect }> "
58     puts "$session_selecting      < #{ $session_selecting.inspect }> "
59     #  puts "$session_buffer         < #{ $session_buffer.inspect }> "
60     #  puts "$session_err            < #{ $session_err.inspect }> "
61     #  puts "$session_out            < #{ $session_out.inspect }> "
62     #  puts "$session_iodat_name     < #{ $session_iodat_name.inspect }> "
63     #  puts "$session_reading        < #{ $session_reading.inspect }> "
64     #  puts "$session_buf            < #{ $session_buf.inspect }> "
65     #  puts "$session_lines          < #{ $session_lines.inspect }> "
66     #  puts "$session_line           < #{ $session_line.inspect }> "
67     #  puts "$session_getting_status < #{ $session_getting_status.inspect }> "
68     self
69     #}}}
70   end
71
72   system "which idl > /dev/null 2>&1"
73   HAVE_IDL = ($?.exitstatus == 0 ? true : false)
74
75   include Session 
76
77   def test_0
78 #{{{
79       sh = nil
80       assert_nothing_raised { sh = Shell.new } 
81 #}}}
82   end
83     
84   def test_1
85 #{{{
86       assert_nothing_raised { 
87         timeout(16) {
88           sh = nil
89           assert_nothing_raised { sh = Shell.new } 
90           sh.execute 'ls' 
91         }
92       }
93 #}}}
94     end
95     def test_3
96 #{{{
97       assert_nothing_raised { 
98         timeout(64) {
99           sh = nil
100           assert_nothing_raised { sh = Shell.new } 
101           128.times { sh.execute 'echo 42' }
102         }
103       }
104 #}}}
105     end
106     def test_4
107 #{{{
108       cmds = ['ls', 'echo 42', 'printf "foobar"', 'printf "foobar\n"'] 
109       assert_nothing_raised { 
110         timeout(64) {
111           sh = nil
112           assert_nothing_raised { sh = Shell.new } 
113           128.times { cmds.each{|cmd| sh.execute cmd;sh.execute "#{cmd} 1>&2"} }
114         }
115       }
116 #}}}
117     end
118     def test_5
119 #{{{
120       assert_nothing_raised { 
121         timeout(16) {
122           sh = nil
123           assert_nothing_raised { sh = Shell.new } 
124           out, err = sh.execute 'echo 42' 
125           assert_equal '42', out.strip
126           out, err = sh.execute 'echo "forty-two" 1>&2' 
127           assert_equal 'forty-two', err.strip
128         }
129       }
130 #}}}
131     end
132     def test_6
133 #{{{
134       out = ''
135       err = ''
136       assert_nothing_raised { 
137         timeout(16) {
138           sh = nil
139           assert_nothing_raised { sh = Shell.new } 
140           sh.execute 'echo 42', :stdout => out, :stderr => err 
141           assert_equal '42', out.strip
142           sh.execute 'echo "forty-two" 1>&2', :stdout => out, :stderr => err
143           assert_equal 'forty-two', err.strip
144         }
145       }
146 #}}}
147     end
148     def test_7
149 #{{{
150     #$DEBUG = true
151       assert_nothing_raised { 
152         timeout(16) {
153           sh = nil
154           assert_nothing_raised { sh = Shell.new } 
155           sh.execute('echo 42') do |out, err|
156             if out
157               assert_equal '42', out.strip
158             end
159           end
160           sh.execute('echo "forty-two" 1>&2') do |out, err|
161             if err
162               assert_equal 'forty-two', err.strip
163             end
164           end
165         }
166       }
167     #ensure
168       #$DEBUG = true
169 #}}}
170     end
171
172 if HAVE_IDL
173     def test_8
174 #{{{
175       assert_nothing_raised { 
176         timeout(16) {
177           idl = nil
178           assert_nothing_raised { idl = IDL.new } 
179
180           out = ''; err = ''
181           idl.execute 'printf, -1, 42', :stdout => out, :stderr => err 
182           assert_equal '42', out.strip
183
184           out = ''; err = ''
185           idl.execute 'printf, -2, \'forty-two\'', :stdout => out, :stderr => err
186           assert_equal 'forty-two', err.strip
187
188           out = ''; err = ''
189           idl.execute 'foo', :stdout => out, :stderr => err
190           assert_match %r/undefined procedure/io, err
191         }
192       }
193 #}}}
194     end
195   end # HAVE_IDL
196   
197     def test_9
198 #{{{
199       assert_nothing_raised { 
200         timeout(16) {
201           lines = []
202           Thread.new {
203             sh = nil
204             assert_nothing_raised { sh = Shell.new } 
205             sh.debug = true
206             #cmd = 'date; sleep 1;' * 3      
207             cmd = 'ruby -e "puts 42; sleep 0.1"' * 3      
208             sh.execute(cmd) do |o,e|
209              line = o || e
210              lines << [Time.now.to_f, line]
211             end
212           }.join
213
214           i = 0
215           while((a = lines[i]) and (b = lines[i + 1]))
216             ta = a.first
217             tb = b.first
218             # they all come back at once if thread hung sending cmd...
219             # make sure we got output about a second apart...
220             begin
221               assert( (tb - ta) >= 0.1 )
222             rescue Exception
223               STDERR.puts "lines : <#{ lines.inspect}>"
224               STDERR.puts "i     : <#{ i }>"
225               STDERR.puts "b     : <#{ b.inspect }>"
226               STDERR.puts "a     : <#{ a.inspect }>"
227               STDERR.puts "tb    : <#{ tb }>"
228               STDERR.puts "ta    : <#{ ta }>"
229               raise
230             end
231             i += 1
232           end
233         }
234       }
235 #}}}
236     end
237
238 end # LibSessionTest