snarl-snp 0.1.1 → 0.2.0

data/spec/snp/request_spec.rb

@@ -1,24 +1,54 @@
-# -*- coding:utf-8 -*-
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 describe "Request" do
 
-  describe "normalize_action" do
-    def normalize_action(action)
-      Snarl::SNP::Request.new.__send__(:normalize_action, action)
+  describe "#normalize_command" do
+    def normalize_cmdkey(command)
+      Snarl::SNP::Request.new.__send__(:normalize_cmdkey, command)
+    end
+    it "returns downcased string" do
+      normalize_cmdkey('action').should eql('action')
+      normalize_cmdkey('Action').should eql('action')
+      normalize_cmdkey(:action).should eql('action')
+    end
+  end
+
+  describe "#normalize_value" do
+    def normalize_value(value)
+      Snarl::SNP::Request.new.__send__(:normalize_value, value)
+    end
+    it 'converts one "\r\n" to one "\n"' do
+      normalize_value("1\r\n2\r\n").should eql("1\n2\n")
+    end
+    it 'converts one "\r" to one "\n"' do
+      normalize_value("1\r2\r").should eql("1\n2\n")
+    end
+    it 'never change multiple "\n\n\n\n\n"' do
+      many_newline = "1\n\n\n\n\n2"
+      normalize_value(many_newline).should eql(many_newline)
+    end
+  end
+
+  describe "#normalize_action_value" do
+    def normalize_action_value(cmdhash)
+      Snarl::SNP::Request.new.__send__(:normalize_action_value, cmdhash)
     end
     it "returns action String, add-class is add_class" do
-      normalize_action('register').should eql('register')
-      normalize_action('add-class').should eql('add_class')
+      normalize_action_value('register').should eql('register')
+      normalize_action_value(:register).should eql('register')
+      normalize_action_value('Register').should eql('register')
+      normalize_action_value('add-class').should eql('add_class')
+      normalize_action_value(:add_class).should eql('add_class')
     end
   end
 
+
   describe "#[]=" do
-    it "set commands with []=" do
+    it "set command pair with normalization" do
       req = Snarl::SNP::Request.new
-      req[:action] = 'register'
-      req['app'] = 'Just Testing...'
-      expected = {"app"=>"Just Testing...", :action =>"register"}
+      req[:action] = 'add-class'
+      req['Class'] = 'Just Testing...'
+      expected = {"class"=>"Just Testing...", 'action' =>"add_class"}
       req.commands.should eql(expected)
     end
   end

data/spec/snp/snp_procedure_spec.rb

@@ -0,0 +1,226 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Snarl::SNP" do
+
+  before :all do
+    @host = '192.168.0.2'
+    @port = 9887
+    @app = Snarl::SNP::DEFAULT_TITLE
+    @class = '1'
+  end
+
+  def snp_open(&block)
+    snp = Snarl::SNP.new(@host, @port)
+    snp.stub!(:send).and_return('SNP/1.1/0/OK/1234/')
+    block.call(snp)
+  end
+
+  describe "#auto_register" do
+    it "do register when snp['app'] exists" do
+      expected = "type=SNP#?version=1.0#?action=register#?app=#{@app}\r\n"
+      snp_open do |snp|
+        snp['app'] = @app
+        snp.auto_register.request_str.should eql(expected)
+      end
+    end
+    it "do nothing when snp['app'] is nil/unset/empty" do
+      snp_open do |snp|
+        snp['app'] = nil
+        snp.auto_register.should be_nil
+      end
+      snp_open do |snp|
+        snp.instance_variable_get(:@config).config.delete('app')
+        snp.auto_register.should be_nil
+      end
+      snp_open do |snp|
+        snp['app'] = ""
+        snp.auto_register.should be_nil
+      end
+    end
+
+  end
+  describe "#auto_add_class" do
+    before :all do
+      classname1, classtitle1 = 'classname1', 'classtitle1'
+      classname2 = 'classname2'
+      @res1 = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{classname1}#?title=#{classtitle1}\r\n"
+      @res2 = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{classname2}\r\n"
+      @classes = [[classname1, classtitle1], [classname2, nil]]
+    end
+
+    it "do register when snp['class'] exists" do
+      expected = [@res1, @res2]
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['class'] = @classes
+        snp.auto_add_class.map{|e| e.request_str}.should eql(expected)
+      end
+    end
+    it "do nothing when snp['class'] is nil/unset/empty" do
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['class'] = nil
+        snp.auto_add_class.should be_nil
+      end
+      snp_open do |snp|
+        snp['app'] = @app
+        snp.instance_variable_get(:@config).config.delete('class')
+        snp.auto_add_class.should be_nil
+      end
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['class'] = []
+        snp.auto_add_class.should be_nil
+      end
+    end
+    it "do nothing when snp['app'] is unset" do
+      snp_open do |snp|
+        snp.instance_variable_get(:@config).config.delete('app')
+        snp['class'] = @classes
+        snp.auto_add_class.should be_nil
+      end
+    end
+  end
+
+  describe "#auto_notification" do
+    it "snp['notification'] == {notify_arg_hash} with snp['app']" do
+      expected = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=title#?text=text#?timeout=10\r\n"
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['notification'] = {'title' => 'title', 'text' => 'text'}
+        snp.auto_notification.request_str.should eql(expected)
+      end
+    end
+    it "snp['notification'] == {notify_arg_hash} without snp['app'] but hash has {'app' => app}" do
+      expected = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=title#?text=text#?timeout=10\r\n"
+      snp_open do |snp|
+        snp['notification'] = {'app' => @app, 'title' => 'title', 'text' => 'text'}
+        snp.auto_notification.request_str.should eql(expected)
+      end
+    end
+    it "snp['notification'] == [notify_arg_array]" do
+      expected = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=title#?text=text#?timeout=9\r\n"
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['notification'] = ['title', 'text', 9]
+        snp.auto_notification.request_str.should eql(expected)
+      end
+    end
+    it "snp['notification'] == [{notify_arg_hash1}, {notify_arg_hash2}, ...]" do
+      arg1 = {'title' => 'title1', 'text' => 'text1', 'timeout' => 8}
+      arg2 = {'title' => 'title2', 'text' => 'text2', 'timeout' => 7}
+      notifications = [arg1, arg2]
+      res1 = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=title1#?text=text1#?timeout=8\r\n"
+      res2 = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=title2#?text=text2#?timeout=7\r\n"
+      expected = [res1, res2]
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['notification'] = notifications
+        snp.auto_notification.map{|res| res.request_str}.should eql(expected)
+      end
+    end
+    it "snp['notification'] == nil, build notify_hash from app,text,title,..." do
+      expected = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?class=class#?title=title#?text=text#?timeout=6\r\n"
+      snp_open do |snp|
+        snp['app'] = @app
+        snp.instance_variable_get(:@config).config.delete('notification')
+        snp['title'] = 'title'
+        snp['text'] = 'text'
+        snp['timeout'] = '6'
+        snp['class'] = 'class'
+        snp.auto_notification.request_str.should eql(expected)
+      end
+    end
+  end
+
+  describe "#auto_unregister" do
+    it "do unregister when snp['unregister'] and snp['app'] exist" do
+      expected = "type=SNP#?version=1.0#?action=unregister#?app=#{@app}\r\n"
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['unregister'] = true
+        snp.auto_unregister.request_str.should eql(expected)
+      end
+    end
+    it "do nothing when snp['unregister'] is nil/unset/false" do
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['unregister'] = nil
+        snp.auto_unregister.should be_nil
+      end
+      snp_open do |snp|
+        snp['app'] = @app
+        snp.instance_variable_get(:@config).config.delete('unregister')
+        snp.auto_unregister.should be_nil
+      end
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['unregister'] = false
+        snp.auto_unregister.should be_nil
+      end
+    end
+    it "do nothing when snp['app'] is nil/unset/empty" do
+      snp_open do |snp|
+        snp['app'] = nil
+        snp['unregister'] = true
+        snp.auto_unregister.should be_nil
+      end
+      snp_open do |snp|
+        snp.instance_variable_get(:@config).config.delete('app')
+        snp['unregister'] = true
+        snp.auto_unregister.should be_nil
+      end
+      snp_open do |snp|
+        snp['app'] = ""
+        snp['unregister'] = true
+        snp.auto_unregister.should be_nil
+      end
+    end
+  end
+
+  describe "#autoexecute_with_config!" do
+    before do
+      @classname, @classtitle = 'classname', 'classtitle'
+      @classes = [[@classname, @classtitle]]
+      @title, @text = 'title', 'text'
+      @notifications = {'title' => @title, 'text' => @text}
+    end
+
+    it "do register and add_class and notification automatically" do
+      res_register = "type=SNP#?version=1.0#?action=register#?app=#{@app}\r\n"
+      res_add_class = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{@classname}#?title=#{@classtitle}\r\n"
+      res_notification = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=#{@title}#?text=#{@text}#?timeout=10\r\n"
+      expected = [res_register, res_add_class, res_notification]
+      snp_open do |snp|
+        snp['app'] = @app
+        snp['add_class'] = @classes
+        snp['notification'] = @notifications
+        snp.autoexecute_with_config!.flatten.map{|res| res.request_str}.should eql(expected)
+      end
+    end
+    it "do nothing if no snp['app'] and snp['add_class'] and snp['notification']" do
+      snp_open do |snp|
+        snp.instance_variable_get(:@config).config.delete('app')
+        snp.instance_variable_get(:@config).config.delete('add_class')
+        snp.instance_variable_get(:@config).config.delete('notification')
+        snp.autoexecute_with_config!.flatten.should eql([nil, nil, nil])
+      end
+    end
+  end
+
+  describe "#apply_yaml" do
+    it "apply yamldata to snp" do
+      app, classname = 'app', 'class'
+      yamldata = "app : #{app}\nclass : #{classname}\n"
+      snp_open do |snp|
+        snp['app'].should be_nil
+        snp['class'].should be_nil
+        snp.apply_yaml(yamldata)
+        snp['app'].should eql(app)
+        snp['class'].should eql([[classname, nil]])
+      end
+    end
+  end
+
+  # describe "#set_logger" #=> real_connection_spec.rb
+end

data/spec/snp/snp_spec.rb

@@ -1,5 +1,5 @@
-# -*- coding:utf-8 -*-
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'stringio'
 
 describe "SNP" do
 
@@ -8,258 +8,281 @@ describe "SNP" do
     @port = 9887
     @app = Snarl::SNP::DEFAULT_TITLE
     @class = '1'
-    Snarl::SNP::Config.reset
+  end
+
+  def snp_open(&block)
+    snp = Snarl::SNP.new(@host, @port)
+    snp.stub!(:send).and_return('SNP/1.1/0/OK/1234/')
+    block.call(snp)
   end
 
   describe "initialize" do
     it "new('192.168.0.2', 9887). (snarl_working_machine_host, snarl_port_9887)" do
       host, port, verbose = '192.168.0.2', 9887, true
       snp = Snarl::SNP.new(host, port, verbose)
-      snp.instance_variable_get(:@host).should eql(host)
-      snp.instance_variable_get(:@port).should eql(port)
+      snp['host'].should eql(host)
+      snp['port'].should eql(port)
       snp.verbose.should eql(verbose)
     end
     it "default host is 127.0.0.1, default port is 9887. when SNP.new()" do
+      bk_host = ENV['SNARL_HOST']
+      ENV['SNARL_HOST'] = nil
+      bk_port = ENV['SNARL_PORT']
+      ENV['SNARL_PORT'] = nil
       snp = Snarl::SNP.new
-      snp.instance_variable_get(:@host).should eql(nil)
-      snp.instance_variable_get(:@port).should eql(nil)
+      snp['host'].should eql('127.0.0.1')
+      snp['port'].should eql(9887)
       snp.verbose.should eql(false)
+      ENV['SNARL_HOST'] = bk_host
+      ENV['SNARL_PORT'] = bk_port
     end
   end
 
   describe "#request" do
-    describe "send raw string" do
-      before :all do
-        @register ="type=SNP#?version=1.0#?action=register#?app=#{@app}\r\n"
-        @add_class = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{@class}\r\n"
-        @notification = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=Raw!#?text=raw message!#?timeout=10\r\n"
-        @unregister = "type=SNP#?version=1.0#?action=unregister#?app=#{@app}\r\n"
+
+    module ErrorPair
+      def self.casual_errors
+        {
+          'SNP/1.1/202/Not Registered' => Snarl::SNP::Error::SNP_ERROR_NOT_REGISTERED,
+          'SNP/1.1/203/Already Registered' => Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED,
+          'SNP/1.1/204/Class Already Exists' => Snarl::SNP::Error::SNP_ERROR_CLASS_ALREADY_EXISTS,
+          'SNP/1.1/201/Not Running' => Snarl::SNP::Error::SNP_ERROR_NOT_RUNNING,
+          'SNP/1.1/101/Failed' => Snarl::SNP::Error::SNP_ERROR_FAILED,
+        }
       end
 
-      it "raises error according to SNP#verbose" do
-        Snarl::SNP.open(@host, @port) do |snp|
-          lambda{
-            snp.request(@register)
-            snp.request(@register)
-          }.should_not raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
-        end
-        Snarl::SNP.open(@host, @port) do |snp|
-          snp.verbose = true
-          lambda{
-            snp.request(@register)
-            snp.request(@register)
-          }.should raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
-        end
+      def self.fatal_errors
+        {
+          'SNP/1.1/102/Unknown Connamd' => Snarl::SNP::Error::SNP_ERROR_UNKNOWN_COMMAND,
+          'SNP/1.1/103/Timed Out' => Snarl::SNP::Error::SNP_ERROR_TIMED_OUT,
+          'SNP/1.1/107/Bad packet' => Snarl::SNP::Error::SNP_ERROR_BAD_PACKET,
+          'SNP/1.1/998/!Snarl::SNP\'s original error(unknown response code)' => Snarl::SNP::Error::RUBYSNARL_UNKNOWN_RESPONSE
+        }
       end
+    end
 
-      it "sends command text" do
-        lambda{
-          Snarl::SNP.open(@host, @port) do |snp|
-            begin
-              snp.request(@register)
-            rescue Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED
-            end
-            begin
-              snp.request(@add_class)
-            rescue Snarl::SNP::Error::SNP_ERROR_CLASS_ALREADY_EXISTS
-            end
-            snp.request(@notification)
-            snp.request(@unregister)
-          end
-        }.should_not raise_error
+    before :all do
+      @register ="type=SNP#?version=1.0#?action=register#?app=#{@app}\r\n"
+      @add_class = "type=SNP#?version=1.0#?action=add_class#?app=#{@app}#?class=#{@class}\r\n"
+      @notification = "type=SNP#?version=1.0#?action=notification#?app=#{@app}#?title=Raw!#?text=text!#?timeout=10\r\n"
+      @unregister = "type=SNP#?version=1.0#?action=unregister#?app=#{@app}\r\n"
+    end
+
+    it "returns SNP::Response object" do
+      snp_open do |snp|
+        snp.request("fake").should be_kind_of(Snarl::SNP::Response)
       end
     end
-    describe "send hash" do
-      before :each do
-        @register = {
-          :action => 'register',
-          :app => @app
-        }
-        @add_class = {
-          :app => @app,
-          :action => 'add_class',
-          :class => @class
-        }
-        @notification = {
-          :app => @app,
-          :action => 'notification',
-          :class => @class,
-          :title => 'command!',
-          :text => 'Hashed message!',
-          :timeout => 10
-        }
-        @unregister = {
-          :action => 'unregister',
-          :app => @app
-        }
+
+    it "if argument is String, it is used as-is" do
+      req_str = "fake"
+      snp_open do |snp|
+        snp.request(req_str).request_str.should eql(req_str)
+      end
+    end
+
+    it "Hash argument is converted in SNP::Request" do
+      notification = {
+        :app => @app,
+        :action => action = 'notification',
+        :class => @class,
+        :title => title = 'title',
+        :text => text = 'text',
+        :timeout => timeout = 9
+      }
+      expected = "type=SNP#?version=1.0#?action=#{action}#?app=#{@app}#?class=#{@class}#?title=#{title}#?text=#{text}#?timeout=#{timeout}\r\n"
+      snp_open do |snp|
+        snp.request(notification).request_str.should eql(expected)
+      end
+    end
+
+    describe "if snp.logger is set, put send/get logs to logger" do
+
+      def sio_logger(sio)
+        logger = Logger.new(sio)
+        logger.datetime_format = ""
+        logger
+      end
+
+      def expected_log_output(str, level='DEBUG')
+        /#{level[0,1]},\s+\[#\d+\]\s+#{Regexp.quote("#{level} -- : #{str}")}/
       end
 
-      it "raises error according to SNP#verbose" do
-        Snarl::SNP.open(@host, @port) do |snp|
-          lambda{
-            snp.request(@register)
-            snp.request(@register)
-          }.should_not raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
+      it "request string is put to log" do
+        log = StringIO.new
+        req_query = "type=SNP#?version=1.0#?action=notification#?title=title#?text=text#?timeout=10"
+        expected =  "notification: \"#{req_query}\""
+        snp_open do |snp|
+          snp.logger = sio_logger(log)
+          snp.notification('title', 'text')
+          log.rewind
+          log.read.should match(expected_log_output(expected, 'DEBUG'))
         end
-        Snarl::SNP.open(@host, @port) do |snp|
-          snp.verbose = true
-          lambda{
-            snp.request(@register)
-            snp.request(@register)
-          }.should raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
+      end
+
+      it "response string is put to log" do
+        log = StringIO.new
+        expected = "notification: SNP/1.1/0/OK/1234/"
+        snp_open do |snp|
+          snp.logger = sio_logger(log)
+          snp.notification('title', 'text')
+          log.rewind
+          log.read.should match(expected_log_output(expected, 'INFO'))
         end
       end
 
-      it "sends command Hash" do
-        lambda{
-          Snarl::SNP.open(@host, @port) do |snp|
-            begin
-              snp.request(@register)
-            rescue Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED
-            end
-            begin
-              snp.request(@add_class)
-            rescue Snarl::SNP::Error::SNP_ERROR_CLASS_ALREADY_EXISTS
-            end
-            snp.request(@notification)
-            snp.request(@unregister)
-          end
-        }.should_not raise_error
+      it "if no casual errors raise, log has 2 lines(reqstr, response)" do
+        log = StringIO.new
+        snp_open do |snp|
+          snp.logger = sio_logger(log)
+          snp.notification('title', 'text')
+          log.rewind
+          log.readlines.size.should eql(2)
+        end
       end
-    end
-  end
 
-  describe "#add_classes" do
-    it "adds two class pair like [['class1', 'one'], ['class2', 'two']]" do
-      classes = [['1', 'one'], ['2', 'two']]
-      lambda{
-        Snarl::SNP.open(@host, @port) do |snp|
-          snp.register(@app)
-          snp.add_classes(classes)
-          snp.notification('First class', '1!', nil, 4, '1')
-          snp.notification('Second class', '2!', nil, 4, '2')
-          snp.unregister(@app)
+      it "casual error is put regardress of snp.verbose" do
+        log = StringIO.new
+        expected = "register: (ignored) (203) Application is already registered"
+        snp_open do |snp|
+          snp.logger = sio_logger(log)
+          snp.stub!(:send).and_return('SNP/1.1/203/Application is already registered')
+          snp.register('Ruby-Snarl')
+          log.rewind
+          log.read.should match(expected_log_output(expected, 'INFO'))
         end
-      }.should_not raise_error
+      end
     end
-  end
 
-  describe "#snarl_hello" do
-    it "returns Snarl release identifier string without popup" do
-      Snarl::SNP.open(@host) do |snp|
-        snp.snarl_hello.should match(/\ASnarl /)
+    describe "raises no Error::Casual when respnse is casual error and setting is default(SNP#verbose is unset, false)" do
+      ErrorPair.casual_errors.each_pair do |res, err|
+        e = <<E
+        it "not raise #{err}" do
+          snp_open do |snp|
+            snp.stub!(:send).and_return("#{res}")
+            lambda{snp.request("fake")}.should_not raise_error(#{err})
+          end
+        end
+E
+        instance_eval(e)
       end
     end
-  end
 
-  describe "#snarl_version" do
-    it "returns Snarl (inner) version string without popup" do
-      Snarl::SNP.open(@host) do |snp|
-        snp.snarl_version.should match(/[\d\.]+/)
+    describe "raises Error::Casual when respnse is casual error and SNP#verbose is set to true" do
+      ErrorPair.casual_errors.each_pair do |res, err|
+        e = <<E
+        it "raise #{err}" do
+          snp_open do |snp|
+            snp.verbose = true
+            snp.stub!(:send).and_return("#{res}")
+            lambda{snp.request("fake")}.should raise_error(#{err})
+          end
+        end
+E
+        instance_eval(e)
       end
     end
-  end
 
-  describe "#iconset" do
-    it "set icon using" do
-      iconset = {:red => 'red.jpg', :blue => 'blue.jpg'}
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.register(@app)
-        snp.iconset(iconset)
-        snp.notification('icon!', 'icon1!', :red, 1).request.to_s.should match(/icon=red\.jpg/)
-        snp.notification('icon!', 'icon2!', :blue, 1).request.to_s.should match(/icon=blue\.jpg/)
+    describe "raises Error::Fatal when response is fatal error" do
+      ErrorPair.fatal_errors.each_pair do |res, err|
+        e = <<E
+        it "raise #{err}" do
+          snp_open do |snp|
+            snp.stub!(:send).and_return("#{res}")
+            lambda{snp.request("fake")}.should raise_error(#{err})
+          end
+        end
+E
+        instance_eval(e)
       end
     end
-  end
 
-  describe ".ping" do
-    it "ping!" do
-      lambda{Snarl::SNP.ping(@host)}.should_not raise_error
-    end
-    it "no host ping!" do
-      Snarl::SNP::Config.host = @host
-      lambda{Snarl::SNP.ping(nil)}.should_not raise_error
+    describe "raises Error::Fatal when response is fatal error regardless of SNP#verbose" do
+      ErrorPair.fatal_errors.each_pair do |res, err|
+        e = <<E
+        it "raise #{err}" do
+          snp_open do |snp|
+            snp.stub!(:send).and_return("#{res}")
+            lambda{snp.request("fake")}.should raise_error(#{err})
+          end
+        end
+E
+        instance_eval(e)
+      end
     end
-  end
 
-  describe ".open{|snp| ...}" do
-    it "supplies Snarl::SNP object block" do
-      Snarl::SNP.open(@host, @port) do |snp|
-        snp.notification('hello!', 10) # TODO: default timeout
+    describe "returns SNP::Response when error does not raise" do
+      it "when SNP/1.1/0/OK, returns its SNP::Response object" do
+        snp_open do |snp|
+          snp.stub!(:send).and_return("SNP/1.1/0/OK")
+          snp.request("fake").inspect.should eql("SNP/1.1/0/OK")
+        end
+      end
+      ErrorPair.casual_errors.keys.each do |res|
+        e = <<E
+        it "when #{res}, returns its SNP::Response object" do
+          snp_open do |snp|
+            snp.stub!(:send).and_return("#{res}")
+            snp.request("fake").inspect.should eql("#{res}")
+          end
+        end
+E
+        instance_eval(e)
       end
     end
-  end
 
-  describe ".show_message" do
-    it "show_message(host, port, title, text, timeout, icon) shows popup message" do
-      lambda{Snarl::SNP.show_message(@host, @port, 'snp_spec', 'test mesage', 2, nil)}.should_not raise_error
-    end
-    it "show_message(host, text) shows popup message with ease" do
-      lambda{Snarl::SNP.show_message(@host, 'short mesage')}.should_not raise_error
-    end
   end
 
-end
-
-describe "SNP1.1 feature" do
-  # NOTE: With "type=SNP#?version=1.0" also works on Snarl R2.21. wow.
+  describe "#add_classes" do
 
-  before :all do
-    @host = '192.168.0.2'
-    @port = 9887
-    @app = Snarl::SNP::DEFAULT_TITLE
-    @class = '1'
+    it "runs add_class for each argument (if Array, use add_classes(*arr))" do
+      classes = [['1', 'one'], ['2', 'two']]
+      snp_open do |snp|
+        snp.register(@app)
+        snp.stub!(:send).and_return{|req| "SNP/1.1/0/OK/#{req.to_s.scan(/class=(\d)/).flatten[0]}"}
+        snp.add_classes(*classes).map{|res| res.infomation}.should eql(['1', '2'])
+        snp.unregister(@app)
+      end
+    end
+    it "runs add_class for multi_class_str each argument" do
+      snp_open do |snp|
+        snp.register(@app)
+        snp.stub!(:send).and_return{|req| "SNP/1.1/0/OK/#{req.to_s.scan(/class=(\d)/).flatten[0]}"}
+        snp.add_classes('1', '2').map{|res| res.infomation}.should eql(['1', '2'])
+        snp.unregister(@app)
+      end
+    end
   end
 
-  # Supports notification feedback forwarding in the form of 3xx codes sent to the remote application's port.
-  ## How test?
-
-  describe "new action" do
-
-    describe "action=hello receives Snarl release identifier (i.e. Snarl R2.21)." do
-      it "type=SNP#?version=1.1#?action=hello\\r\\n" do
-        Snarl::SNP.open(@host) do |snp|
-          res = snp.request("type=SNP#?version=1.1#?action=hello\r\n")
-          res.inspect.should match(/\ASNP\/1.1\/0\/OK\/Snarl /)
-        end
+  describe "#snarl_hello" do
+    it "returns Snarl release identifier string without popup" do
+      snp_open do |snp|
+        snp.stub!(:send).and_return("SNP/1.1/0/OK/Snarl R2.21")
+        expected = "Snarl R2.21"
+        snp.snarl_hello.should eql(expected)
       end
     end
+  end
 
-    describe "action=version receives Snarl (inner) version (i.e. 40.15)" do
-      it "type=SNP#?version=1.1#?action=version\\r\\n" do
-        Snarl::SNP.open(@host) do |snp|
-          res = snp.request("type=SNP#?version=1.1#?action=version\r\n")
-          res.inspect.should match(/\ASNP\/1.1\/0\/OK\/[\d\.]+\Z/)
-        end
+  describe "#snarl_version" do
+    it "returns Snarl (inner) version string without popup" do
+      snp_open do |snp|
+        snp.stub!(:send).and_return("SNP/1.1/0/OK/40.15")
+        expected = "40.15"
+        snp.snarl_version.should eql(expected)
       end
     end
-
   end
 
-  describe "notification returns notification token value." do
-    it "counter?" do
-      Snarl::SNP.open(@host) do |snp|
+  describe "#iconset" do
+    it "set icon using" do
+      iconset = {:red => 'red.jpg', :blue => 'blue.jpg'}
+      snp_open do |snp|
         snp.register(@app)
-        snp.add_class(@class)
-        res = snp.request("type=SNP#?version=1.1#?action=notification#?app=#{@app}#?title=1.1!#?text=val!#?timeout=2\r\n")
-        res.inspect.should match(/\ASNP\/1.1\/0\/OK\/\d+\Z/)
-        snp.unregister(@class)
+        snp.iconset(iconset)
+        snp.notification('icon!', 'icon1!', :red, 1).request_str.should match(/icon=red\.jpg/)
+        snp.notification('icon!', 'icon2!', :blue, 1).request_str.should match(/icon=blue\.jpg/)
       end
     end
   end
-
-#   describe "notification icon path can be URL" do
-#     it "use Google News Icon" do
-#       lambda{
-#         Snarl::SNP.open(@host) do |snp|
-#           snp.register(@app)
-#           snp.add_class(@class)
-#           icon = 'http://www.google.com/images/newspaper.gif'
-#           res = snp.request("type=SNP#?version=1.1#?action=notification#?app=#{@app}#?title=1.1!#?text=Google News!!#?timeout=4#?icon=#{icon}\r\n")
-#           snp.unregister(@class)
-#         end
-#       }.should_not raise_error
-#     end
-#   end
 end
-