rsql 0.2.6 → 0.2.7

data/test/test_eval_context.rb

@@ -1,179 +0,0 @@
-#!/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(19, 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

@@ -1,130 +0,0 @@
-#!/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
-
-end # class TestMySQLResults