rsql 0.2.7 → 0.2.8

data/test/test_commands.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+require 'mocha'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib')) << File.dirname(__FILE__)
+require 'rsql/mysql_results.rb'
+require 'rsql/eval_context.rb'
+require 'rsql/commands.rb'
+
+class TestCommands < Test::Unit::TestCase
+
+    include RSQL
+
+    def setup
+        @orig_stdout = $stdout
+        $stdout = @strout = StringIO.new
+        @ctx = EvalContext.new
+        @conn = mock('Mysql')
+        @conn.expects(:list_dbs).returns([])
+        MySQLResults.conn = @conn
+    end
+
+    def teardown
+        $stdout = @orig_stdout
+    end
+
+    def test_simple_ruby
+        cmds = Commands.new('. puts :hello', :display_by_column)
+        assert_equal(false, cmds.empty?)
+        assert_not_nil(cmds.last)
+        cmds.run!(@ctx)
+        assert_equal('hello', @strout.string.chomp)
+    end
+
+    def test_simple_sql
+        cmds = Commands.new('do some silly stuff', :display_by_column)
+        @conn.expects(:query).with(instance_of(String)).returns(nil)
+        @conn.expects(:affected_rows).returns(1)
+        cmds.run!(@ctx)
+        assert_match(/Query OK, 1 row affected/, @strout.string)
+    end
+
+    def test_separators
+        cmds = Commands.new('. puts :hello\; puts :world;', :display_by_column)
+        cmds.run!(@ctx)
+        assert_equal('hello'+$/+'world', @strout.string.chomp)
+
+        # make sure our logic to handle eval'd blocks with args works
+        @strout.string = ''
+        cmds = Commands.new('. Proc.new{|a| puts a.inspect} | @results.value.call(:fancy)', :display_by_column)
+        cmds.run!(@ctx)
+        assert_equal(':fancy', @strout.string.chomp)
+    end
+
+    def test_multiple
+        @conn.expects(:query).with('one thing').returns(nil)
+        @conn.expects(:affected_rows).returns(1)
+        cmds = Commands.new('. "one thing" ; . puts :hello.inspect', :display_by_column)
+        cmds.run!(@ctx)
+        assert_match(/^QueryOK,1rowaffected\(\d+.\d+sec\):hello$/,
+                     @strout.string.gsub(/\s+/,''))
+    end
+
+    def test_bangs
+        cmds = Commands.new('silly stuff ! this => that', :display_by_column)
+        @conn.expects(:query).with('silly stuff').returns(nil)
+        @conn.expects(:affected_rows).returns(13)
+        cmds.run!(@ctx)
+        assert_match(/Query OK, 13 rows affected/, @strout.string)
+
+        # now test logic to continue if it _doesn't_ look like a bang
+        cmds = Commands.new('silly stuff ! more things', :display_by_column)
+        @conn.expects(:query).with('silly stuff ! more things').returns(nil)
+        @conn.expects(:affected_rows).returns(4)
+        cmds.run!(@ctx)
+        assert_match(/Query OK, 4 rows affected/, @strout.string)
+    end
+
+end # class TestCommands

data/test/test_eval_context.rb

@@ -0,0 +1,179 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'tempfile'
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+require 'mocha'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib')) << File.dirname(__FILE__)
+require 'rsql/mysql_results.rb'
+require 'rsql/eval_context.rb'
+
+class TestEvalContext < Test::Unit::TestCase
+
+    include RSQL
+
+    def setup
+        @conn = mock('Mysql')
+        @conn.expects(:list_dbs).returns([])
+        @conn.expects(:query).with(instance_of(String)).returns(nil)
+        @conn.expects(:affected_rows).returns(0)
+        MySQLResults.conn = @conn
+        @ctx = EvalContext.new
+        @ctx.load(File.join(File.dirname(__FILE__),'..','example.rsqlrc'))
+    end
+
+    def test_reload
+        orig = $stdout
+        $stdout = out = StringIO.new
+        @conn.expects(:query).with(instance_of(String)).returns(nil)
+        @conn.expects(:affected_rows).returns(0)
+        @ctx.safe_eval('reload', nil, out)
+        assert_match(/loaded: .+?example.rsqlrc/, out.string)
+    ensure
+        $stdout = orig
+    end
+
+    def test_eval
+        out = StringIO.new
+
+        # test a simple string registration
+        val = @ctx.safe_eval('cleanup_example', nil, out)
+        assert_equal('DROP TEMPORARY TABLE IF EXISTS rsql_example;', val)
+        assert_equal(true, out.string.empty?)
+
+        # test a block registration
+        val = @ctx.safe_eval('fill_table', nil, out)
+        assert_match(/(INSERT IGNORE INTO .+?){10}/, val)
+        assert_equal(true, out.string.empty?)
+
+        # test results handling and output redirection
+        res = mock
+        res.expects(:each_hash).yields({'value' => '2352'})
+        val = @ctx.safe_eval('to_report', res, out)
+        assert_equal(nil, val)
+        assert_equal("There are 1 small values and 0 big values.", out.string.chomp)
+    end
+
+    def test_list
+        out = StringIO.new
+        val = @ctx.safe_eval('list', nil, out)
+        assert_match(/usage\s+description/, out.string)
+    end
+
+    def test_params
+        val = @ctx.safe_eval('params("ft", @registrations[:fill_table].block)', nil, nil)
+        assert_equal('', val)
+        val = @ctx.safe_eval('params("sv", @registrations[:save_values].block)', nil, nil)
+        assert_equal('(fn)', val)
+    end
+
+    def test_desc
+        out = StringIO.new
+        err = StringIO.new
+        orig_err = $stderr
+
+        $stderr = err
+        val = @ctx.safe_eval('desc max_rows', nil, out)
+        $sterr = orig_err
+        assert_equal('', out.string)
+        assert_equal('refusing to describe EvalContext#max_rows',
+                     err.string.chomp)
+
+        err.string = ''
+        $stderr = err
+        val = @ctx.safe_eval('desc :sldkfjas', nil, out)
+        $sterr = orig_err
+        assert_equal('', out.string)
+        assert_equal('nothing registered as sldkfjas', err.string.chomp)
+
+        err.string = ''
+        $stderr = err
+        val = @ctx.safe_eval('desc :version', nil, out)
+        $sterr = orig_err
+        assert_equal('', out.string)
+        assert_equal('refusing to describe the version method', err.string.chomp)
+
+        err.string = ''
+        out.string = ''
+        val = @ctx.safe_eval('desc :cleanup_example', nil, out)
+        assert_equal('', err.string)
+        assert_match(
+            /^\s*\[.+\/example.rsqlrc:\d+\]\s+DROP TEMPORARY TABLE IF EXISTS \#\{@rsql_table\}\s*$/,
+            out.string)
+
+        out.string = ''
+        val = @ctx.safe_eval('desc :to_report', nil, out)
+        lines = out.string.split($/).select{|l|l.any?}
+        assert_match(/^\[.+\/example.rsqlrc:\d+\]$/, lines[0])
+        assert_match(/^register .+ do$/, lines[1])
+        assert_match(/^\s+puts/, lines[-2])
+        assert_match(/^end$/, lines[-1])
+        assert_equal(13, lines.size)
+    end
+
+    def test_complete
+        out = @ctx.complete('')
+        assert_equal(20, out.size, out.inspect)
+        assert_equal(['version'], @ctx.complete('v'))
+        assert_equal(['.version'], @ctx.complete('.v'))
+    end
+
+    def test_bang_eval
+        @ctx.bangs = {'time' => :relative_time}
+        t = (Time.now - 2532435).to_s
+        assert_equal(t, @ctx.bang_eval('do no harm', t))
+        assert_equal(' 29 days ago', @ctx.bang_eval('time', t))
+    end
+
+    def test_humanize
+        out = StringIO.new
+        assert_equal('   9.16 GB',
+                     @ctx.safe_eval('humanize_bytes(9832742324)', nil, out))
+        assert_equal(9835475108,
+                     @ctx.safe_eval('dehumanize_bytes("   9.16 GB")', nil, out))
+        assert_equal(' 20.9%',
+                     @ctx.safe_eval('humanize_percentage(0.209384)', nil, out))
+        assert(out.string.empty?)
+    end
+
+    def test_hex
+        bin = ''
+        100.times{|i| bin << i}
+        hex = @ctx.to_hexstr(bin)
+        assert_equal('0x000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f' <<
+                     '... (68 bytes hidden)', hex)
+
+        out = StringIO.new
+        assert_equal('0x1234', @ctx.safe_eval('hexify("1234")', nil, out))
+        assert_equal('0x1234', @ctx.safe_eval('hexify("0x1234")', nil, out))
+        assert_equal('0x1234', @ctx.safe_eval('hexify(0x1234)', nil, out))
+        assert(out.string.empty?)
+    end
+
+    def test_safe_save
+        out = StringIO.new
+        @ctx.safe_eval('@mystuff = {:one => 1, :two => 2}', nil, out)
+        tf = Tempfile.new('mystuff')
+        @ctx.safe_eval("safe_save(@mystuff, '#{tf.path}')", nil, out)
+        tf = tf.path + '.yml'
+        assert_equal("Saved: #{tf}", out.string.chomp)
+        assert_equal({:one => 1, :two => 2}, YAML.load_file(tf))
+
+        # now make sure it keeps one backup copy
+        out = StringIO.new
+        @ctx.safe_eval('@mystuff = {:one => 1}', nil, out)
+        @ctx.safe_eval("safe_save(@mystuff, '#{tf}')", nil, out)
+        assert_equal("Saved: #{tf}", out.string.chomp)
+        assert_equal({:one => 1}, YAML.load_file(tf))
+        assert_equal({:one => 1, :two => 2}, YAML.load_file(tf+'~'))
+    ensure
+        File.unlink(tf) if File.exists?(tf)
+        File.unlink(tf+'~') if File.exists?(tf+'~')
+    end
+
+end # class TestEvalContext

data/test/test_mysql_results.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+
+begin
+    require 'rubygems'
+rescue LoadError
+end
+require 'mocha'
+
+$: << File.expand_path(File.join(File.dirname(__FILE__),'..','lib')) << File.dirname(__FILE__)
+require 'rsql/mysql_results.rb'
+
+class TestMySQLResults < Test::Unit::TestCase
+
+    include RSQL
+
+    def setup
+        MySQLResults.conn = nil
+        MySQLResults.database_name = nil
+        MySQLResults.reset_cache
+    end
+
+    def test_databases
+        assert_equal([], MySQLResults.databases)
+        conn = mock('Mysql')
+        conn.expects(:list_dbs).returns(['accounts'])
+        conn.expects(:select_db)
+        conn.expects(:list_tables).returns([])
+        MySQLResults.conn = conn
+        assert_equal(['accounts'], MySQLResults.databases)
+    end
+
+    def test_tables
+        assert_equal([], MySQLResults.tables)
+        MySQLResults.reset_cache
+
+        conn = mock('Mysql')
+        conn.expects(:list_dbs).returns(['accounts'])
+        conn.expects(:select_db)
+        conn.expects(:list_tables).returns(['users','groups'])
+        MySQLResults.conn = conn
+
+        assert_equal([], MySQLResults.tables)
+        MySQLResults.database_name = 'accounts'
+        assert_equal(['groups','users'], MySQLResults.tables)
+        assert_equal(['groups','users'], MySQLResults.tables('accounts'))
+    end
+
+    def test_complete
+        assert_equal([], MySQLResults.complete(nil))
+
+        conn = mock('Mysql')
+        conn.expects(:list_dbs).returns(['Accounts','Devices','Locations'])
+        conn.expects(:select_db).times(3)
+        tbls = sequence(:tbls)
+        conn.expects(:list_tables).in_sequence(tbls).returns(['Prefs','Names'])
+        conn.expects(:list_tables).in_sequence(tbls).returns(['IPs'])
+        conn.expects(:list_tables).in_sequence(tbls).returns(['Street','City','State'])
+        MySQLResults.conn = conn
+
+        assert_equal(['Accounts','Devices','Locations'], MySQLResults.complete(''))
+        assert_equal(['Accounts'], MySQLResults.complete('a'))
+
+        MySQLResults.database_name = 'Accounts'
+        assert_equal(['Devices','Locations','Names','Prefs'], MySQLResults.complete(''))
+        assert_equal(['Names'], MySQLResults.complete('n'))
+
+        assert_equal(['Accounts.Names','Accounts.Prefs'], MySQLResults.complete('accounts.'))
+    end
+
+    def test_query
+        f1 = mock('f1')
+        f1.expects(:name).returns('c1').times(12)
+        f1.expects(:type).returns(1).times(2)
+        f2 = mock('f2')
+        f2.expects(:name).returns('c2').times(11)
+        f2.expects(:type).returns(1).times(2)
+
+        res = mock('results')
+        res.expects(:num_rows).returns(2).times(2)
+        res.expects(:fetch_fields).returns([f1,f2])
+
+        rows = sequence(:rows)
+        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+
+        conn = mock('Mysql')
+        conn.expects(:list_dbs).returns([])
+        conn.expects(:query).with(instance_of(String)).returns(res)
+        conn.expects(:affected_rows).returns(1)
+        MySQLResults.conn = conn
+
+        bangs = mock('bangs')
+        bangs.expects(:bang_eval).with(instance_of(String),instance_of(String)).
+            returns('val').times(4)
+
+        mres = MySQLResults.query('ignored', bangs)
+        assert_equal('ignored', mres.sql)
+        assert_equal(true, mres.any?)
+        assert_equal(false, mres.empty?)
+        assert_equal(2, mres.num_rows)
+        assert_equal({"c1"=>"val", "c2"=>"val"}, mres[0])
+        assert_equal({"c1"=>"val", "c2"=>"val"}, mres[1])
+        assert_equal(nil, mres[2])
+
+        cnt = 0
+        mres.each_hash do |row|
+            cnt += 1
+            assert_equal({"c1"=>"val", "c2"=>"val"}, row)
+        end
+        assert_equal(2, cnt)
+
+        dout = StringIO.new
+        mres.display_by_column(dout)
+        assert_match(/^c1c2--------valvalvalval--------2rowsinset/,
+                     dout.string.gsub(/\s+/,''))
+
+        dout = StringIO.new
+        mres.display_by_batch(dout)
+        assert_equal('valvalvalval', dout.string.gsub(/\s+/,''))
+
+        dout = StringIO.new
+        mres.display_by_line(dout)
+        assert_match(/^\*+1.row\*+c1:valc2:val\*+2.row\*+c1:valc2:val2rowsinset/,
+                     dout.string.gsub(/\s+/,''))
+    end
+
+    def test_grep
+        f1 = mock('f1')
+        f1.stubs(:name).returns('c1')
+        f1.stubs(:type).returns(1)
+        f2 = mock('f2')
+        f2.stubs(:name).returns('c2')
+        f2.stubs(:type).returns(1)
+
+        res = mock('results')
+        res.stubs(:num_rows).returns(2)
+        res.stubs(:fetch_fields).returns([f1,f2])
+
+        rows = sequence(:rows)
+        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+
+        conn = mock('Mysql')
+        conn.stubs(:list_dbs).returns([])
+        conn.stubs(:query).with(instance_of(String)).returns(res)
+        conn.stubs(:affected_rows).returns(1)
+        MySQLResults.reset_history
+        MySQLResults.conn = conn
+
+        mres = MySQLResults.query('ignored1', eval_context=nil, raw=true)
+        assert_equal(false, mres.grep(/val/))
+
+        rows = sequence(:rows)
+        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+
+        mres = MySQLResults.query('ignored2', eval_context=nil, raw=true)
+        assert_equal(true, mres.grep('v1', :fixed))
+        assert_equal("\e[31;1mv1\e[0m.1", mres[0]['c1'])
+        assert_equal("\e[31;1mv1\e[0m.2", mres[0]['c2'])
+
+        rows = sequence(:rows)
+        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+
+        mres = MySQLResults.query('ignored3', eval_context=nil, raw=true)
+        assert_equal(false, mres.grep('v', :fixed, :inverse))
+
+        rows = sequence(:rows)
+        res.expects(:fetch_row).in_sequence(rows).returns(['v1.1','v1.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(['v2.1','v2.2'])
+        res.expects(:fetch_row).in_sequence(rows).returns(nil)
+
+        mres = MySQLResults.query('ignored4', eval_context=nil, raw=true)
+        assert_equal(true, mres.grep('v1.1', :nocolor))
+        assert_equal("v1.1", mres[0]['c1'])
+
+        # fixme: technically should be in it's only test...
+        cmds = []
+        4.times{|i| cmds << "ignored#{i+1}"}
+        assert_equal(cmds, MySQLResults.history)
+        assert_equal([cmds.last], MySQLResults.history(1))
+        assert_equal(cmds, MySQLResults.history(15))
+    end
+
+end # class TestMySQLResults