snarl-snp 0.1.1 → 0.2.0

data/spec/snp/config_spec.rb

@@ -1,53 +1,197 @@
-# -*- coding:utf-8 -*-
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
-describe "Config" do
+describe "Snarl::SNP::Config" do
+
+  before :all do
+    @host   = '0.0.0.0'
+    @port   = 9876
+    @app    = 'app'
+    @class1 = 'class1'
+    @classtitle1 = @class1 + 'title'
+    @class2 = 'class2'
+    @class3 = 'class3'
+    @title = 'title'
+    @timeout = 9
+    @icon = 'icon.jpg'
+    @text = 'text'
+
+    # just only for bypassing emacs ruby-mode indent bug, class is "class"
+    @yaml = <<YAML
+host : #{@host}
+port : #{@port}
+app  : #{@app}
+"class" :
+  - [#{@class1}, #{@classtitle1}]
+  - [#{@class2}]
+  - #{@class3}
+notification :
+  title : #{@title}
+  text : #{@text}
+  timeout : #{@timeout}
+  icon : #{@icon}
+  "class" : #{@class1}
+unregister : false
+logfile : $stdout
+loglevel : 0
+YAML
+  end
 
   before do
-    Snarl::SNP::Config.reset
   end
 
-  describe ".host=" do
-    it "set host into String" do
-      Snarl::SNP::Config.host = 1234
-      Snarl::SNP::Config.host.should eql('1234')
+  describe ".initialize" do
+    before :all do
+      @backup_host = ENV['SNARL_HOST']
+      @backup_port = ENV['SNARL_PORT']
     end
-    it "set nil, returns default" do
-      config = Snarl::SNP::Config.new
-      Snarl::SNP::Config.host = nil
-      Snarl::SNP::Config.host.should eql(Snarl::SNP::Config::DEFAULT_HOST)
+    after :all do
+      ENV['SNARL_HOST'] = @backup_host
+      ENV['SNARL_PORT'] = @backup_port
+    end
+
+    it "When ENV['SNARL_PORT'] is nil, default host is 127.0.0.1" do
+      ENV['SNARL_HOST'] = nil
+      Snarl::SNP::Config.new['host'].should eql('127.0.0.1')
+    end
+    it "When ENV['SNARL_PORT'] is set, default host is SNARL_HOST" do
+      ENV['SNARL_HOST'] = '192.168.0.2'
+      Snarl::SNP::Config.new['host'].should eql('192.168.0.2')
+    end
+
+    it "When ENV['SNARL_PORT'] is nil, default port is 9887.to_i" do
+      ENV['SNARL_PORT'] = nil
+      Snarl::SNP::Config.new['port'].should eql(9887)
+    end
+    it "When ENV['SNARL_PORT'] is set, default port is SNARL_PORT.to_i" do
+      ENV['SNARL_PORT'] = '12345'
+      Snarl::SNP::Config.new['port'].should eql(12345)
     end
   end
 
-  describe ".port=" do
-    it "set port into Integer" do
-      Snarl::SNP::Config.port = '9887'
-      Snarl::SNP::Config.port.should eql(9887)
+  describe "#[]=" do
+    it "config['app'] = 'appname' works" do
+      appname = 'appname'
+      config = Snarl::SNP::Config.new
+      config['app'] = appname
+      config.instance_variable_get(:@config)['app'].should eql(appname)
     end
-    it "set nil, returns default" do
-      Snarl::SNP::Config.port = nil
-      Snarl::SNP::Config.port.should eql(Snarl::SNP::Config::DEFAULT_PORT)
+    it "Symbol key converts to String. config[':app'] = 'appname' works" do
+      appname = 'appname'
+      config = Snarl::SNP::Config.new
+      config[:app] = appname
+      config.instance_variable_get(:@config)['app'].should eql(appname)
     end
   end
 
-#   describe ".load_snp_config" do
-
-#     before do
-#       @yaml = Tempfile.new('rubysnarlsnpconfigspec')
-#     end
-#     after do
-#       @yaml.close
-#     end
-
-#     it "read yaml from argument path" do
-#       host = '192.168.0.2'
-#       port = 9887
-#       @yaml.write("host : #{host}\nport : #{port}")
-#       @yaml.close
-#       config = Snarl::SNP::Config.load_snp_config(@yaml.path)
-#       config.host.should eql(host)
-#       config.port.should eql(port) # YAML.load('9887') #=> Integer
-#     end
-#   end
+  describe "#[]" do
+    it "returns @config[k]" do
+      appname = 'appname'
+      config = Snarl::SNP::Config.new
+      config.instance_variable_get(:@config)['app'] = appname
+      config['app'].should eql(appname)
+    end
+  end
 
+  describe "Config" do
+
+    describe ".store" do
+      it "normalize pair and store to hash" do
+        expected = {
+          "host"         => "0.0.0.0",
+          "port"         => 9876,
+          "app"          => "app",
+          "class"        => [["class1", "class1title"], ["class2", nil], ["class3", nil]],
+          "notification" => {
+            "title"   => "title",
+            "text"    => "text",
+            "timeout" => 9,
+            "icon"    => "icon.jpg",
+            "class"   => "class1",
+          },
+          "unregister"   => false,
+          "logfile"      => $stdout,
+          "loglevel"     => 0
+        }
+        actual = {}
+        YAML.load(@yaml).each do |k, v|
+          Snarl::SNP::Config::Normalize.store(k, v, actual)
+        end
+        actual.should eql(expected)
+      end
+    end
+
+    describe "#extract_classes" do
+      def extract_classes(v)
+        Snarl::SNP::Config::Normalize.new('dum','my').__send__(:extract_classes, v)
+      end
+
+      it "if [[class1, title1]], return as is" do
+        actual = [['class1', 'title1']]
+        expected = actual
+        extract_classes(actual).should eql(expected)
+      end
+      it "if [classonly], returns [[classonly, nil]]" do
+        actual = ['class1']
+        expected = [['class1', nil]]
+        extract_classes(actual).should eql(expected)
+      end
+      it "if is String, returns [[string, nil]]" do
+        actual = 'class1'
+        expected = [['class1', nil]]
+        extract_classes(actual).should eql(expected)
+      end
+      it "if is nil, returns nil" do
+        actual = nil
+        expected = nil
+        extract_classes(actual).should eql(expected)
+      end
+    end
+
+    describe "#extract_loglevel" do
+      def extract_loglevel(v)
+        Snarl::SNP::Config::Normalize.new('dum','my').__send__(:extract_loglevel, v)
+      end
+
+      it "if integer string, returns s.to_i" do
+        extract_loglevel('1').should eql(1)
+      end
+      it "if yaml_undef, returns 0" do
+        extract_loglevel(nil).should eql(0)
+        extract_loglevel('').should eql(0)
+      end
+      it "if .to_s matches /\A(debug|info|warn|error|fatal)\Z/i, returns 0-4" do
+        extract_loglevel('debug').should eql(0)
+        extract_loglevel('INFO').should eql(1)
+        extract_loglevel('Warn').should eql(2)
+        extract_loglevel(:error).should eql(3)
+        extract_loglevel(:FATAL).should eql(4)
+      end
+      it "if unknown str, returns 0" do
+        extract_loglevel('foo').should eql(0)
+      end
+    end
+
+    describe "#extract_logfile" do
+      def extract_logfile(v)
+        Snarl::SNP::Config::Normalize.new('dum','my').__send__(:extract_logfile, v)
+      end
+
+      it "if '$stdout' or '$stderr', returns its IO object" do
+        extract_logfile('$stdout').should eql($stdout)
+        extract_logfile('$stderr').should eql($stderr)
+      end
+      it "returns it as is unless $stdout or $stderr" do
+        actual = expected = 'logfile'
+        extract_logfile(actual).should eql(expected)
+      end
+    end
+
+    describe "#normalize" do
+      def normalize(k, v)
+        Snarl::SNP::Config::Normalize.new(k, v).normalize
+      end
+      # ah...
+      # pending('I do not want to write now')
+    end
+  end
 end

data/spec/snp/real_connection_spec.rb

@@ -0,0 +1,295 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Snarl::SNP" do
+
+  before :all do
+    @host = SNARL_HOST # from spec_helper
+    @port = SNARL_PORT # from spec_helper
+    @app = Snarl::SNP::DEFAULT_TITLE
+    @class = '1'
+  end
+
+  describe ".open{|snp| ...}" do
+    it "supplies Snarl::SNP object block" do
+      Snarl::SNP.open(@host, @port) do |snp|
+        snp.notification('hello Snarl::SNP test!', 10)
+      end
+    end
+  end
+
+  def snp_open(&block)
+    snp = Snarl::SNP.new(@host, @port)
+    block.call(snp)
+  end
+
+  it "full SNP popup procedure goes well" do
+    lambda{
+      snp_open do |snp|
+        snp.register(@app)
+        snp.add_class(@class, 'classtitle')
+        res = snp.notification('tit', 'tex(no icon popups)', 'ico', 9, @class)
+        snp.unregister(@app)
+      end
+    }.should_not raise_error
+  end
+
+  describe "#register" do
+    it "twice raises error SNP_ERROR_ALREADY_REGISTERED" do
+      snp_open do |snp|
+        snp.register(@app)
+        snp.verbose = true
+        lambda{snp.register(@app)}.should raise_error(Snarl::SNP::Error::SNP_ERROR_ALREADY_REGISTERED)
+        snp.unregister(@app)
+      end
+    end
+    it "empty app raises error SNP_ERROR_BAD_PACKET" do
+      snp_open do |snp|
+        snp.verbose = true
+        lambda{snp.register('')}.should raise_error(Snarl::SNP::Error::SNP_ERROR_BAD_PACKET)
+      end
+    end
+  end
+
+  describe "#add_class" do
+    it "empty classtitle raises no error" do
+      snp_open do |snp|
+        snp.register(@app)
+        snp.verbose = true
+        lambda{snp.add_class(@class)}.should_not raise_error(Snarl::SNP::Error)
+        snp.unregister(@app)
+      end
+    end
+    it "add same class raises error SNP_ERROR_CLASS_ALREADY_EXISTS" do
+      snp_open do |snp|
+        snp.register(@app)
+        snp.add_class(@class)
+        snp.verbose = true
+        lambda{snp.add_class(@class)}.should raise_error(Snarl::SNP::Error::SNP_ERROR_CLASS_ALREADY_EXISTS)
+        snp.unregister(@app)
+      end
+    end
+    it "empty class raises error SNP_ERROR_BAD_PACKET" do
+      snp_open do |snp|
+        snp.register(@app)
+        snp.verbose = true
+        lambda{snp.add_class('')}.should raise_error(Snarl::SNP::Error::SNP_ERROR_BAD_PACKET)
+      end
+    end
+  end
+
+  describe "#notification" do
+    it "'anonymous-class' notification is not considered as a bad packet" do
+      snp_open do |snp|
+        lambda{
+          snp.register(@app)
+          snp.verbose = true
+          snp.notification(:text => 'anonymous class test', :timeout => '2')
+        }.should_not raise_error(Snarl::SNP::Error)
+      end
+    end
+    it "'anonymous-app' notification is not considered as a bad packet" do
+      snp_open do |snp|
+        lambda{
+          snp.verbose = true
+          snp.notification(:text => 'anonymous app test', :timeout => '2')
+        }.should_not raise_error(Snarl::SNP::Error)
+      end
+    end
+  end
+
+  describe "#unregister" do
+    it "unregister before registering raises error SNP_ERROR_NOT_REGISTERED" do
+      snp_open do |snp|
+        snp.unregister(@app)
+        snp.verbose = true
+        lambda{snp.unregister(@app)}.should raise_error(Snarl::SNP::Error::SNP_ERROR_NOT_REGISTERED)
+      end
+    end
+    it "empty app raises error SNP_ERROR_BAD_PACKET" do
+      snp_open do |snp|
+        snp.verbose = true
+        lambda{snp.unregister('')}.should raise_error(Snarl::SNP::Error::SNP_ERROR_BAD_PACKET)
+      end
+    end
+  end
+
+  describe "#hello" do
+    it "returns Snarl release identifier" do
+      snp_open do |snp|
+        snp.hello.infomation.should match(/\ASnarl /)
+      end
+    end
+  end
+
+  describe "#version" do
+    it "returns Snarl (inner) version" do
+      snp_open do |snp|
+        snp.version.infomation.should match(/[\d\.]+/)
+      end
+    end
+  end
+
+  describe "#request" do
+    it "misspelling action raises SNP_ERROR_BAD_PACKET" do
+      snp_open do |snp|
+        lambda{
+          snp.request("type=SNP#?version=1.0#?action=notification2#?app=#{@app}#?title=err!#?text=this never popup#?timeout=10\r\n")
+        }.should raise_error(Snarl::SNP::Error::SNP_ERROR_BAD_PACKET)
+      end
+    end
+  end
+
+  # FIXME: I have no idea to let class methods run under #stub!
+
+  describe ".ping" do
+    it "ping" do
+      expected = "type=SNP#?version=1.0#?action=notification#?title=Ruby-Snarl#?text=Ruby Snarl-SNP Ping Message#?timeout=10#?icon=3\r\n"
+      Snarl::SNP.ping(@host).request_str.should eql(expected)
+    end
+  end
+
+  describe ".show_message" do
+    it "show_message(host, port, title, text, timeout, icon) shows popup message" do
+      expected = "type=SNP#?version=1.0#?action=notification#?title=snp_spec#?text=test mesage#?timeout=2#?icon=icon\r\n"
+      Snarl::SNP.show_message(@host, @port, 'snp_spec', 'test mesage', 2, 'icon').request_str.should eql(expected)
+    end
+    it "if port Integer is omitted, (host, title, text, timeout, icon) is treated as (host, nil, title, text, timeout, icon)" do
+      expected = "type=SNP#?version=1.0#?action=notification#?title=snp_spec#?text=test mesage#?timeout=2#?icon=icon\r\n"
+      Snarl::SNP.show_message(@host, 'snp_spec', 'test mesage', 2, 'icon').request_str.should eql(expected)
+    end
+  end
+
+  # ============================================
+  # snp_procedure.rb
+
+  describe ".load" do
+    it "SNP.load(yaml){...} loads yaml and executes as SNP" do
+      yaml = <<EOY # for bypassing emacs ruby-mode indent bug, 'class : ...' is '"class" : ...'
+host : #{@host}
+port : #{@port}
+app : Ruby-Snarl
+"class" : class1
+EOY
+      lambda{
+        Snarl::SNP.load(yaml) do |snp|
+          snp.notification('yaml load test')
+        end
+      }.should_not raise_error
+    end
+    it "SNP.load(yaml_with_notify) loads yaml and executes as SNP automatically" do
+      yaml = <<EOY # for bypassing emacs ruby-mode indent bug, 'class : ...' is '"class" : ...'
+host : #{@host}
+port : #{@port}
+app : Ruby-Snarl
+"class" : class1
+title : yaml test
+text : hello,yaml!
+EOY
+      lambda{
+        Snarl::SNP.load(yaml) do |snp|
+          snp.notification('yaml load test')
+        end
+      }.should_not raise_error
+    end
+    it "SNP.load(yaml, Logger.new){...} puts SNPProcedure log to Logger" do
+      sio = StringIO.new
+      logger = Logger.new(sio)
+      yaml = <<EOY
+host : #{@host}
+port : #{@port}
+app : Ruby-Snarl
+EOY
+      expected = Regexp.quote('register: "type=SNP#?version=1.0#?action=register#?app=Ruby-Snarl')
+      Snarl::SNP.load(yaml, logger) do |snp|
+      end
+      sio.rewind
+      sio.read.should match(expected)
+    end
+  end
+
+  describe "#set_logger" do
+    before :all do
+      @yaml = <<EOY
+host : #{@host}
+port : #{@port}
+app : Ruby-Snarl
+EOY
+    end
+
+    before do
+      @logpath = Tempfile.new('snarlsnprealconnectionspecrb').path
+    end
+
+    it "set logger_obj as snp['logger'] when load(yaml, logger_obj)" do
+      logger = Logger.new(@logpath)
+      Snarl::SNP.load(@yaml, logger) do |snp|
+        snp.logger.should eql(logger)
+      end
+    end
+
+    it "set Logger.new(string) as snp['logger'] when load(yaml, string)" do
+      logger = @logpath
+      expected = Regexp.quote('register: "type=SNP#?version=1.0#?action=register#?app=Ruby-Snarl')
+      Snarl::SNP.load(@yaml, logger) do |snp|
+      end
+      File.open(logger){|f| f.read}.should match(expected)
+    end
+
+    it "set Logger.new(logpath) as snp['logger'] when load(\"logfile : logpath\")" do
+      yaml = "#{@yaml}\nlogfile : #{@logpath}"
+      expected = Regexp.quote('register: "type=SNP#?version=1.0#?action=register#?app=Ruby-Snarl')
+      Snarl::SNP.load(yaml) do |snp|
+      end
+      File.open(@logpath){|f| f.read}.should match(expected)
+    end
+
+    it "set lvl to Logger.new(file_y).level when load(\"logfile : file_y\\nloglevel : lvl\")" do
+      loglevel = 4
+      yaml = "#{@yaml}\nlogfile : #{@logpath}\nloglevel : #{loglevel}"
+      Snarl::SNP.load(yaml) do |snp|
+        snp.logger.level.should eql(loglevel)
+      end
+    end
+
+    it "does not set lvl to load_arg_logger.level when load(\"loglevel : lvl\", load_arg_logger)" do
+      loglevel = 4
+      logger = @logpath
+      yaml = "#{@yaml}\nloglevel : #{loglevel}"
+      Snarl::SNP.load(yaml, logger) do |snp|
+        snp.logger.level.should_not eql(loglevel)
+        snp.logger.level.should eql(0)
+      end
+    end
+  end
+
+  # =============================================
+  # bin/snarl_snp.rb
+  if defined?(TEST_SNARL_SNP_BIN_SPEC) then
+    class ::SNPBin
+      remove_const :"BINCMD_OPTION"
+    end
+  else
+    TEST_SNARL_SNP_BIN_SPEC=true
+  end
+  load File.expand_path(File.dirname(__FILE__) + '/../../bin/snarl_snp')
+
+  describe "SNPBin" do
+
+    before :all do
+      @argv_bak = ARGV.dup
+    end
+    after :all do
+      ARGV.replace(@argv_bak)
+    end
+
+    describe "run" do
+      it "#exec_snplib" do
+        arg = ['-H', SNARL_HOST, '-p', SNARL_PORT.to_s, '-a', 'Ruby-Snarl', '-c', 'class', '-m', 'exec text']
+        ARGV.replace([__FILE__] + arg)
+        lambda{
+          SNPBin.new.run
+        }.should_not raise_error
+      end
+    end
+  end
+end