termtter 1.5.0 → 1.6.0

data/spec/plugins/whois_spec_.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Termtter::Client, 'when the plugin whois is loaded' do
+  it 'should add command whois' do
+    Termtter::Client.should_receive(:register_command).once
+    Termtter::Client.plug 'whois'
+  end
+
+  it 'should be whois define' do
+    Termtter::Client.plug 'whois'
+    name = "jp-in-f104.google.com"
+    ip = "66.249.89.104"
+    
+    whois?(name).should == ip
+    whois?(ip).should == name 
+  end
+  
+end

data/spec/spec_helper.rb

@@ -4,4 +4,29 @@ $:.unshift(File.dirname(__FILE__) + '/../lib')
 ARGV.delete '-c'
 require 'termtter'
 
+def be_quiet(options = {})
+  out = (v = options.delete(:stdout)).nil? ? true : v
+  err = (v = options.delete(:stderr)).nil? ? true : v
+  if out
+    out_dummy = StringIO.new
+    $stdout, out_orig = out_dummy, $stdout
+  end
+  if err
+    err_dummy = StringIO.new
+    $stderr, err_orig = err_dummy, $stderr
+  end
+  yield
+  result = {}
+  if out
+    $stdout = out_orig
+    out_dummy.rewind
+    result[:stdout] = out_dummy.read
+  end
+  if err
+    $stderr = err_orig
+    err_dummy.rewind
+    result[:stderr] = err_dummy.read
+  end
+  result
+end
 

data/spec/termtter/active_rubytter_spec.rb

@@ -12,12 +12,29 @@ module Termtter
       d.age.should == 16
     end
 
+    it 'Hashのキーでもメソッドでもないものは呼べない' do
+      d = ActiveRubytter.new(:name => 'termtter')
+      lambda{ d.undefined_method }.should raise_error(NoMethodError)
+    end
+
     it '元のHashを得られること' do
       data = { :test => 'test' }
       d = ActiveRubytter.new(data)
       d.to_hash.should == data
     end
 
+    it 'idというkeyがあっても取得できる' do
+      data = { :id => 'test' }
+      d = ActiveRubytter.new(data)
+      d.id.should == 'test'
+    end
+
+    it '[]でもアクセス出来る' do
+      data = { :hoge => 'test' }
+      d = ActiveRubytter.new(data)
+      d[:hoge].should == 'test'
+    end
+
     describe '入れ子のHashの処理' do
 
       before(:all) do

data/spec/termtter/api_spec.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module Termtter
+
+  describe API do
+
+    it 'tries authenticate 3 times' do
+      API.should_receive(:try_auth).
+        exactly(3).times.
+        and_return(false)
+      API.should_receive(:exit!)
+      API.setup
+    end
+
+    it 'can get twitter when success authentication' do
+      twitter = mock('twitter')
+      API.should_receive(:try_auth).and_return(twitter)
+      API.setup
+      API.twitter.should == twitter
+    end
+
+    def it_should_examine_with(name, pass, options = {})
+      config.user_name = name if name
+      config.password  = pass if pass
+
+      dummy_out = mock('stdout')
+      dummy_out.stub(:ask) do |ask, _|
+        $stdout.puts ask
+        result = options.delete(
+          case ask
+          when /Username/ then :ui_name
+          when /Password/ then :ui_pass
+          end
+        ) || ''
+        result
+      end
+      API.stub(:create_highline => dummy_out)
+
+      twitter = mock('twitter')
+      twitter.stub(:verify_credentials) do
+        if config.user_name.empty? || config.password.empty?
+          raise Rubytter::APIError.new('error')
+        end
+      end
+      RubytterProxy.stub(:new => twitter)
+
+      API.try_auth.should == yield(twitter)
+
+      config.__clear__(:user_name)
+      config.__clear__(:password)
+    end
+
+    it 'can examine username and password (success)' do
+      it_should_examine_with('test', 'pass') {|twitter| twitter }
+    end
+
+    it 'can examine username and password (only name)' do
+      result = be_quiet(:stderr => false) {
+        it_should_examine_with('test', nil) { nil }
+      }
+      result[:stdout].should ==
+        "Please enter your Twitter login:\nPassword: \n"
+    end
+
+    it 'can examine username and password (only pass)' do
+      result = be_quiet(:stderr => false) {
+        it_should_examine_with(nil, 'pass') { nil }
+      }
+      result[:stdout].should ==
+        "Please enter your Twitter login:\nUsername: \n"
+    end
+
+    it 'can examine username and password (both nil)' do
+      result = be_quiet(:stderr => false) {
+        it_should_examine_with(nil, nil) { nil }
+      }
+      result[:stdout].should ==
+        "Please enter your Twitter login:\nUsername: \nPassword: \n"
+    end
+
+    it 'can examine username and password (enter password)' do
+      be_quiet do
+        args = ['test', nil, {:ui_pass => 'pass'}]
+        it_should_examine_with(*args) {|twitter| twitter }
+      end
+    end
+
+    it 'can examine username and password (enter username)' do
+      be_quiet do
+        args = [nil, 'pass', {:ui_name => 'test'}]
+        it_should_examine_with(*args) {|twitter| twitter }
+      end
+    end
+
+    it 'can examine username and password (enter both)' do
+      be_quiet do
+        args = [nil, nil,
+          {:ui_name => 'test',
+           :ui_pass => 'pass' }]
+        it_should_examine_with(*args) {|twitter| twitter }
+      end
+    end
+  end
+end
+

data/spec/termtter/client_spec.rb

@@ -5,6 +5,83 @@ module Termtter
   describe Client do
     before do
       Client.setup_logger
+      Client.setup_task_manager
+      Client.clear_filter
+      Client.clear_command
+      Client.clear_hooks
+    end
+
+    # FIXME: Depends recent implement
+    it 'can run' do
+      Client.should_receive(:load_config) {}
+      Termtter::API.should_receive(:setup) {}
+      Client.should_receive(:setup_logger) {}
+      Client.should_receive(:load_plugins) {}
+      Client.should_receive(:eval_init_block) {}
+
+      config.system.eval_scripts = []
+      config.system.cmd_mode = true
+      Client.run
+    end
+
+    it 'can run (eval script cannot eval)' do
+      Client.stub(:load_config) {}
+      Termtter::API.stub(:setup) {}
+      Client.stub(:setup_logger) {}
+      Client.stub(:load_plugins) {}
+      Client.stub(:eval_init_block) {}
+
+      config.system.eval_scripts = ['raise']
+      Client.should_receive(:handle_error)
+
+      config.system.cmd_mode = true
+      Client.run
+    end
+
+    it 'can run (eval script cannot eval)' do
+      Client.stub(:load_config) {}
+      Termtter::API.stub(:setup) {}
+      Client.stub(:setup_logger) {}
+      Client.stub(:load_plugins) {}
+      Client.stub(:eval_init_block) {}
+
+      config.system.eval_scripts = []
+      config.system.cmd_mode = false
+      Client.should_receive(:call_hooks).with(:initialize)
+      Client.should_receive(:call_hooks).with(:launched)
+      Client.run
+    end
+
+    it 'set init block' do
+      dummy = lambda {}
+      Client.init(&dummy)
+      Client.instance_variable_get(:@init_block).should == dummy
+    end
+
+    it 'can run init block' do
+      Client.init() {}
+      Client.instance_variable_get(:@init_block).
+        should_receive(:call).with(Client)
+      Client.eval_init_block
+    end
+
+    it 'can load plugins when initializing stage (normal)' do
+      config.devel = false
+      Client.should_receive(:plug).exactly(2).times
+      Client.load_plugins
+    end
+
+    it 'can load plugins when initializing stage (devel)' do
+      Client.should_receive(:plug).exactly(2).times
+      Client.load_plugins
+    end
+
+    it 'can pause and resume' do
+      manager = Client.instance_variable_get(:@task_manager)
+      manager.should_receive(:pause)
+      Client.pause
+      manager.should_receive(:resume)
+      Client.resume
     end
 
     it 'takes command' do
@@ -41,6 +118,15 @@ module Termtter
       }.should_not raise_error
     end
 
+    it 'register_command can raise error when take invalid argument' do
+      [1, ['hoge', 'fuga'], nil, Object.new].each do |bad|
+        lambda {
+          Client.register_command(bad)
+        }.should raise_error(ArgumentError)
+      end
+    end
+
+
     it 'takes add_command as block' do
       Client.add_command('test') do |c|
         c.aliases = ['t']
@@ -77,51 +163,17 @@ module Termtter
         ['test  foo bar ',  'foo bar'],
         ['test  foo  bar ', 'foo  bar'],
       ].each do |input, args|
-        Client.call_commands(input)
+        status = Client.call_commands(input)
         command_arg.should == args
+        status.should == 0
       end
     end
 
-    it 'takes new_hook' do
-      hook = Hook.new(:name => :test)
-      Client.register_hook(hook)
-      Client.get_hook(:test).should == hook
-    end
-
-    it 'takes hook as Hash' do
-      Client.register_hook(:name => :test)
-      Client.get_hook(:test).name.should == :test
-    end
-
-    it 'calls new_hook' do
-      hook_called = false
-      Client.register_hook(:name => :test1, :points => [:point1], :exec_proc => lambda {hook_called = true})
-      hook_called.should == false
-      Client.call_hooks(:point1)
-      hook_called.should == true
-    end
-
-    it 'calls new_hook with args' do
-      arg1 = nil
-      arg2 = nil
-      Client.register_hook(:name => :test1, :points => [:point1], :exec_proc => lambda {|a1, a2| arg1 = a1; arg2 = a2})
-      arg1.should == nil
-      arg2.should == nil
-      Client.call_hooks(:point1, 'foo', 'bar')
-      arg1.should == 'foo'
-      arg2.should == 'bar'
-    end
-
-    it 'return hooks when call get_hooks' do
-      hook1 = Client.register_hook(:name => :test1, :points => [:point1])
-      hook2 = Client.register_hook(:name => :test2, :points => [:point1])
-      hook3 = Client.register_hook(:name => :test3, :points => [:point2])
-
-      hooks = Client.get_hooks(:point1)
-      hooks.size.should == 2
-      hooks.include?(hook1).should == true
-      hooks.include?(hook2).should == true
-      hooks.include?(hook3).should == false
+    it 'can clear commands' do
+      Client.instance_variable_set(:@commands, {:hoge => 'piyo'})
+      Client.commands.should_not be_empty
+      Client.clear_command
+      Client.commands.should be_empty
     end
 
     it 'calls decide_arg hooks' do
@@ -134,11 +186,11 @@ module Termtter
       Client.register_hook( :name => :test2,
                             :points => [:pre_exec_update],
                             :exec_proc => lambda {|cmd, arg| decided_arg = arg})
-      Client.register_command(:name => :update, :aliases => [:u], :exec => lambda{|arg|})
+      Client.register_command(:name => :update, :aliases => [:u], :exec => lambda{|_|})
 
-      input_command.should == nil
-      input_arg.should == nil
-      decided_arg.should == nil
+      input_command.should be_nil
+      input_arg.should be_nil
+      decided_arg.should be_nil
       Client.call_commands('u foo')
       input_command.should == 'u'
       input_arg.should == 'foo'
@@ -222,6 +274,8 @@ module Termtter
 
       hook_called.should == false
       Client.should_receive(:puts)
+      Client.instance_variable_get(:@task_manager).
+        should_receive(:kill) {}
       Client.exit
       hook_called.should == true
     end
@@ -234,6 +288,7 @@ module Termtter
 
       hook1_called.should == false
       hook2_called.should == false
+      Client.instance_variable_get(:@task_manager).stub(:kill)
       Client.should_receive(:puts)
       Client.exit
       hook1_called.should == true
@@ -277,38 +332,105 @@ module Termtter
       }.should_not raise_error
     end
 
-    it 'runs' do
-      pending
-      Client.should_receive(:load_config)
-      Termtter::API.should_receive(:setup)
-      Client.should_receive(:start_input_thread)
-      Client.run
-    end
-
-    it 'load_config'
-
-    it 'does nothing when ~/.termtter is directory' do
-      File.should_receive(:ftype).and_return('directory')
-      Client.should_not_receive(:move_legacy_config_file)
-      Client.legacy_config_support
+    it 'can apply filter' do
+      statuses = [
+        { :id => 2,
+          :created_at => Time.now,
+          :user_id => 2,
+          :name => 'name',
+          :screen_name => 'screen name',
+          :source => 'termtter',
+          :reply_to => 1,
+          :text => 'hi',
+          :original_data => 'hi' }
+      ]
+      event     = :output_for_test
+      hook_name = :my_hook
+
+      hook = Client.register_hook(hook_name) {|s, e| s.text.should == 'hi'; e.should == event }
+      hook.should_receive(:call)
+      Client.should_receive(:get_hooks).with(hook_name).and_return([hook])
+      Client.apply_filters_for_hook(hook_name, statuses, event)
+    end
+
+    it 'can add macro' do
+      Client.should_receive(:register_command).
+        with {|arg| arg.should be_an_instance_of(Hash) }
+      Client.register_macro('greet', "update %s")
+    end
+
+    it 'can clear hooks' do
+      Client.instance_variable_set(:@hooks, {:hoge => 'piyo'})
+      Client.hooks.should_not be_empty
+      Client.clear_hooks
+      Client.hooks.should be_empty
+    end
+
+    it 'can load config' do
+      Client.should_receive(:load).with(Termtter::CONF_FILE)
+      Client.load_config
+    end
+
+    it 'can create config file when load_config' do
+      File.should_receive(:exist?).twice.and_return(false)
+      require 'termtter/config_setup'
+      ConfigSetup.should_receive(:run).and_return(false)
+      Client.stub(:load).with(Termtter::CONF_FILE)
+      Client.load_config
+    end
+
+    it 'can output status (bad)' do
+      Client.should_not_receive(:call_hooks)
+      Client.output(nil, :hoge)
+      Client.should_not_receive(:call_hooks)
+      Client.output([], :hoge)
+    end
+
+    # FIXME: too dirty
+    it 'can output status (good)' do
+      statuses = mock('statuses', :null_object => true)
+      statuses.stub(:empty? => false, :nil? => false)
+      event = :event
+      Client.should_receive(:call_hooks).with(:pre_filter, statuses, event)
+      Client.should_receive(:apply_filters_for_hook).exactly(2).times.
+        with(an_instance_of(Symbol), anything, event).
+        and_return(statuses)
+      Client.should_receive(:call_hooks).with(:post_filter, statuses, event)
+      hook = mock(:hook, :name => 'test')
+      hook.should_receive(:call).with(anything, event)
+      Client.should_receive(:get_hooks).with(:output).and_return([hook])
+      Client.output(statuses, event)
+    end
+
+    it 'can clear filters' do
+      Client.instance_variable_set(:@filters, [:hoge, :piyo])
+      Client.instance_variable_get(:@filters).should_not be_empty
+      Client.clear_filter
+      Client.instance_variable_get(:@filters).should be_empty
+    end
+
+    it 'handles error (not devel)' do
+      logger = Client.logger
+      logger.should_receive(:error).with("StandardError: error")
+      Client.handle_error StandardError.new('error')
     end
 
-    it 'does "move_legacy_config_file" when ~/.termtter is file' do
-      File.should_receive(:ftype).and_return('file')
-      Client.should_receive(:move_legacy_config_file)
-      Client.legacy_config_support
+    it 'handles error (devel)' do
+      config.devel = true
+      logger = Client.logger
+      logger.should_receive(:error).with("StandardError: error").twice
+      error = StandardError.new('error')
+      error.stub(:backtrace).and_return(["StandardError: error"])
+      Client.handle_error error
     end
 
-    it 'moves legacy config file' do
-      FileUtils.should_receive(:mv).twice
-      Dir.should_receive(:mkdir)
-      Client.move_legacy_config_file
-    end
-
-    it 'handles error' do
-      logger = Client.instance_eval{@logger}
-      logger.should_receive(:error).with("StandardError: error")
-      Client.handle_error StandardError.new('error')
+    it 'handle_error raise error when logger is nothing' do
+      Client.instance_variable_set(:@logger, nil)
+      $stderr, old = StringIO.new, $stderr
+      Client.handle_error(StandardError.new('error'))
+      $stderr.rewind
+      $stderr.gets.should match(/\AError: error/)
+      $stderr = old
     end
 
     it 'cancels command by hook' do
@@ -326,6 +448,7 @@ module Termtter
     end
 
     it 'gets default help' do
+      Client.plug 'defaults' # FIXME: Do not need
       $stdout, old_stdout = StringIO.new, $stdout # FIXME That suspends any debug informations!
       help_command = Client.get_command(:help)
       help_command.should_not be_nil
@@ -335,6 +458,7 @@ module Termtter
     end
 
     it 'gets an added help' do
+      Client.plug 'defaults' # FIXME: Do not need
       Client.register_command(
         :name => :foo,
         :help => [
@@ -350,6 +474,71 @@ module Termtter
       $stdout.string.should match(/foo list/)
     end
 
+    it 'can confirm before update (yes default)' do
+      message = 'hello'
+      Readline.should_receive(:readline).
+        with("\"#{message}".strip + "\" [Y/n] ", false)
+      Client.confirm(message)
+    end
+
+    it 'can confirm before update (no default)' do
+      message = 'hello'
+      Readline.should_receive(:readline).
+        with("\"#{message}".strip + "\" [N/y] ", false)
+      Client.confirm(message, false)
+    end
+
+    it 'can configm before update' do
+      ok_pattern = [ 'y', 'Y', '' ]
+      ng_pattern = [
+        'n', 'N',
+        ('a'..'z').to_a,
+        ('A'..'Z').to_a ].flatten
+      ng_pattern -= ['y', 'Y']
+
+      ok_pattern.each do |ask|
+        Readline.should_receive(:readline).and_return(ask)
+        Client.confirm('hello').should be_true
+      end
+      ng_pattern.each do |ask|
+        Readline.should_receive(:readline).and_return(ask)
+        Client.confirm('hello').should be_false
+      end
+    end
+
+    it 'confirm can take block as callback' do
+      Readline.stub(:readline => 'y')
+      called = false
+      Client.confirm('hello') { called = true }
+      called.should be_true
+    end
+
+    it 'default logger can cahnge error to fit security level' do
+      logger = Client.default_logger
+      TermColor.should_receive(:parse).with(match(/blue/))
+      logger.debug 'hi'
+      TermColor.should_receive(:parse).with(match(/cyan/))
+      logger.info 'hi'
+      TermColor.should_receive(:parse).with(match(/magenta/))
+      logger.warn 'hi'
+      TermColor.should_receive(:parse).with(match(/red/))
+      logger.error 'hi'
+      TermColor.should_receive(:parse).with(match(/on_red/))
+      logger.fatal 'hi'
+      TermColor.should_receive(:parse).with(match(/white/))
+      logger.unknown 'hi'
+    end
+
+    it 'can cancel command' do
+      text = 'text'
+      command = mock('command', :null_object => true)
+      command.stub(:call) { raise CommandCanceled }
+      Client.stub(:find_commands).with(text).and_return([command])
+      lambda {
+        Client.call_commands(text).should == 1
+      }.should_not raise_error
+    end
+
     describe 'add commands' do
       before(:each) do
         Client.clear_command

data/spec/termtter/command_spec.rb

@@ -77,6 +77,11 @@ module Termtter
       end
     end
 
+    it 'returns empty array as candidates when competition_proc is nil'do
+      command = Command.new(:name => :foo)
+      command.complement('foo bar').should == []
+    end
+
     it 'returns command_info when call method "match?"' do
       [
         ['update',       true],
@@ -123,18 +128,39 @@ module Termtter
     end
 
     describe '.split_command_line' do
+      before do
+        @command = Command.new(:name => 'test')
+      end
+
       it 'splits from a command line string to the command name and the arg' do
-        Command.split_command_line('test foo bar').
+        @command.split_command_line('test foo bar').
           should == ['test', 'foo bar']
-        Command.split_command_line('test   foo bar').
+        @command.split_command_line('test   foo bar').
           should == ['test', 'foo bar']
-        Command.split_command_line('test   foo  bar').
+        @command.split_command_line('test   foo  bar').
           should == ['test', 'foo  bar']
-        Command.split_command_line(' test   foo  bar').
+        @command.split_command_line(' test   foo  bar').
           should == ['test', 'foo  bar']
-        Command.split_command_line(' test   foo  bar ').
+        @command.split_command_line(' test   foo  bar ').
           should == ['test', 'foo  bar']
       end
     end
+
+    describe 'spec for split_command_line with sub command' do
+      before do
+        @command = Command.new(:name => 'foo bar')
+      end
+
+      it 'splits from a command line string to the command name and the arg' do
+        @command.split_command_line('foo bar args').
+          should == ['foo bar', 'args']
+        @command.split_command_line('foo  bar args').
+          should == ['foo bar', 'args']
+        @command.split_command_line(' foo  bar  args ').
+          should == ['foo bar', 'args']
+        @command.split_command_line(' foo  foo  args ').
+          should == ['foo foo', 'args']
+      end
+    end
   end
 end

data/spec/termtter/config_setup_spec.rb

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+
+require File.dirname(__FILE__) + '/../spec_helper'
+require 'termtter/config_setup'
+
+module Termtter
+  describe ConfigSetup do
+    it "check inputed values" do
+      highline = mock('mock', :ask => 'username_or_password')
+      ConfigSetup.stub(:create_highline).and_return(highline)
+      File.stub(:exists?).and_return(true)
+      io = StringIO.new
+      File.stub(:open).and_yield(io)
+      ConfigSetup.run
+      io.rewind
+      io.read.should match(/username_or_password/)
+    end
+  end
+end