libmagellan 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34304b7e7ce13311b97b509bd020f47705a919e3
-  data.tar.gz: c3673f6d4c027ddca67e7778e42dc6ec67379cfb
+  metadata.gz: bedd53b1539db040b551014161d7032cd4d9a99d
+  data.tar.gz: 72f92926594578d22e69eee7c9e7e6ac85157898
 SHA512:
-  metadata.gz: e6dbb4e6ae4c066e0c9daccf968b328c86b5c93f283e7b04f945e8ad9b2e754a0e9780da53e29233597aded96732aec01824dbb6cc0f3325b9d89205a61f6b7b
-  data.tar.gz: 17ff66c7e2ab7cbf5e3dc9a75d29990d7f3fef15834ee0eb236b0480f9ad6dfb1f1140f63b8f6d6aa5cbae2dd292a66099abf34fc575c56a40a601dfab826408
+  metadata.gz: 8b691e66274cb81dfcc18b5d5ff31d00d2d5e326494e1f6cd9c7c45f1f02f5514d9bb1ab97f93dded805d0e55de276f3884fdf264dff38b501285645dd8f70ce
+  data.tar.gz: 263eca336003094a605da01331eb8cf7a8a050322bc05be91bc18eb57486ca6e51cbc5c9fa40760d51540d682b3bb996889f1edac74b7433ba767de4337930f1

data/lib/libmagellan.rb

@@ -1,11 +1,14 @@
 require "libmagellan/version"
 
 module Libmagellan
-  autoload :Base, "libmagellan/base"
+  autoload :Core, "libmagellan/core"
+  autoload :HTTP, "libmagellan/http"
+  autoload :MQTT, "libmagellan/mqtt"
+
 
   class << self
     def new(*args, &block)
-      Base.new(*args, &block)
+      Core.new(*args, &block)
     end
   end
 

data/lib/libmagellan/core.rb

@@ -0,0 +1,109 @@
+require 'libmagellan'
+
+require 'logger'
+
+
+module Libmagellan
+
+  class Core
+
+    DEFAULT_LOG_LEVEL = Logger::INFO
+
+    def initialize(*args)
+      # HTTP
+      @http = HTTP.new(*args.dup)
+
+      # MQTT
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      mqtt_options = options.dup
+      if mqtt_options[:mqtt_host].present? and mqtt_options[:mqtt_port].present?
+        mqtt_options[:host] = mqtt_options.delete(:mqtt_host)
+        mqtt_options[:port] = mqtt_options.delete(:mqtt_port)
+        @mqtt = MQTT.new(mqtt_options)
+        @mqtt.logger = logger
+      end
+    end
+
+
+    ##
+    ## HTTP
+    ##
+
+    def request(*args, &block)
+      @http.request(*args, &block)
+    end
+    alias :req :request
+
+    def ping
+      @http.ping
+    end
+
+    def test_ping(*args)
+      @http.test_ping(*args)
+    end
+
+    def test(*args, &block)
+      @http.test(*args, &block)
+    end
+
+    def json_body(r)
+      @http.json_body(r)
+    end
+
+
+
+    ##
+    ## MQTT
+    ##
+
+    def mqtt_token(path, method=:get, body="", headers={})
+      r = request(path, method, body, headers)
+      if r.code.to_i >= 200 and r.code.to_i < 300
+        token = r['authorization']
+        @mqtt.token = token if @mqtt
+        token
+      else
+        r
+      end
+    end
+
+    def publish(*args)
+      @mqtt.publish(*args)
+    end
+    alias :pub :publish
+
+    def subscribe(*args, &block)
+      @mqtt.subscribe(*args, &block)
+    end
+    alias :sub :subscribe
+
+    def disconnet
+      @mqtt.disconnect
+    end
+
+    def get_message(*args, &block)
+      @mqtt.get(*args, &block)
+    end
+
+
+    def logger
+      @logger ||= Proc.new {
+        logger = ::Logger.new(STDOUT)
+        logger.level = DEFAULT_LOG_LEVEL
+        logger
+      }.call
+    end
+
+    def logger=(logger_)
+      @logger = logger_
+    end
+
+    # Set logger log level
+    # @param [Integer] level Log level
+    def log_level=(level)
+      logger.level = level
+    end
+
+  end
+
+end

data/lib/libmagellan/{base.rb → http.rb}

@@ -6,7 +6,7 @@ require "signet/oauth_1/client"
 require 'active_support/core_ext/object/blank'
 
 module Libmagellan
-  class Base
+  class HTTP
 
     DEFAULT_OPTIONS = {
       consumer_key: "groovenauts-test",
@@ -36,6 +36,9 @@ module Libmagellan
     end
 
     def request_without_oauth(path, method=:get, body="", headers={})
+      if body.is_a?(Hash)
+        body = URI.encode_www_form(body)
+      end
       uri = URI.join(@base_uri.to_s, path)
       http_client = Net::HTTP.new(uri.host, uri.port)
       http_client.use_ssl = true if uri.scheme == 'https'

data/lib/libmagellan/mqtt.rb

@@ -0,0 +1,248 @@
+# coding: utf-8
+require 'libmagellan'
+
+require 'base64'
+require 'json'
+require 'active_support/core_ext'
+require 'signet/oauth_1/client'
+require 'mqtt'
+
+
+module Libmagellan
+
+  class MQTT
+
+    AUTH_BASE_URL = "mqtt://mqtt.magellanic-clouds.com".freeze
+    MQTT_METHOD = "mqtt".freeze
+    PROTOCOL = "mqtt".freeze
+
+    LOG_LEVELS = {
+      debug: Logger::DEBUG,
+      info:  Logger::INFO,
+      warn:  Logger::WARN,
+      error: Logger::ERROR,
+      fatal: Logger::FATAL,
+    }
+    DEFAULT_LOG_LEVEL = Logger::INFO
+
+    COLOURS = {
+      red:    "\e[31m",
+      blue:   "\e[34m",
+      green:  "\e[32m",
+      yellow: "\e[33m",
+      white:  "\e[37m",
+    }
+
+    OPTIONS = {
+      host: {required: true},
+      port: {required: true},
+      consumer_key: {required: true},
+      consumer_secret: {required: true},
+      client_version: {required: true},
+    }.freeze
+
+    attr_accessor :host, :port, :consumer_key, :consumer_secret, :client_version
+    attr_reader   :client
+    attr_accessor :token
+
+    # MQTT Client
+    # @param [Hash] args MQTT Arguments
+    # @option args [String] :host MQTT server host address
+    # @option args [Integer] :port MQTT server port
+    # @option args [String] :consumer_key MQTT authorization consumer-key
+    # @option args [String] :consumer_key MQTT authorization consumer-secret
+    def initialize(args={})
+      args, errors = validate_args(args)
+      show_errors(errors, initialize_usage()) if errors.present?
+
+      @host = args.delete(:host)
+      @port = args.delete(:port)
+      @consumer_key = args.delete(:consumer_key)
+      @consumer_secret = args.delete(:consumer_secret)
+      @client_version = args.delete(:client_version)
+
+      @token = nil
+      @client = nil
+    end
+
+
+    # Publish message to MQTT server.
+    # @param [String] topic Topic name
+    # @param [String] payload Payload
+    def publish(topic, payload)
+      payload = payload.to_json unless payload.is_a?(::String)
+      with_connection do |c|
+        c.publish(topic, payload)
+        log("[PUBLISH] #{topic}: #{payload}", Logger::DEBUG)
+      end
+    end
+    alias :pub :publish
+
+    # Subscribe topic(s)
+    # @param [String|Array] topics Subscribe topics
+    def subscribe(topics, &block)
+      topics = [topics] unless topics.is_a?(::Array)
+      topics = topics.select{|t| t.is_a?(::String) }
+      with_connection do |c|
+        c.subscribe(*topics)
+        topics.each {|t| log("[SUBSCRIBE] #{t}", Logger::DEBUG) }
+      end
+      if block_given?
+        get(nil, &block)
+      end
+    end
+    alias :sub :subscribe
+
+    # Get message to me
+    # @param [String] topic Topic name
+    # @return [Array] topic and payload
+    def get(topic=nil)
+      with_connection do |c|
+        if block_given?
+          c.get(topic) do |topic_, message_|
+            yield(topic_, message_)
+          end
+        else
+          # return topic, payload
+          c.get(topic)
+        end
+      end
+    end
+
+
+    # MQTT Disconnect
+    def disconect
+      connection.disconnect if connected?
+    end
+
+    # @return [Logger]
+    def logger
+      @logger_
+    end
+
+    def logger=(logger_)
+      @logger_ = logger_
+    end
+
+
+
+    private
+
+
+    # Send command to MQTT server.
+    # Connect MQTT server if it is not has connection.
+    def with_connection
+      yield(connection()) if block_given?
+    end
+
+    # Connect MQTT server
+    # @return [MQTT::Client] MQTT Client
+    def connection
+      if connected?
+        return @client
+      else
+        if @token.present?
+        # トークンによる認証
+          connect(@consumer_key, @token)
+        else
+          # OAuthによる認証
+          auth = generate_oauth_header(AUTH_BASE_URL, @consumer_key, @consumer_secret)
+          headers = "Authorization: #{auth}; Client-Version: #{@client_version}"
+          password = Base64.urlsafe_encode64(headers)
+          connect(@consumer_key, password)
+        end
+      end
+    end
+
+    # Connect to MQTT Server
+    # @param [String] username Username
+    # @param [String] password Password
+    # @return [MQTT::Client] MQTT Client
+    def connect(username, password)
+      mqtt_host = "#{@host}:#{@port.to_s}"
+      uri = "#{PROTOCOL}://#{username}:#{password}@#{mqtt_host}"
+      @client = ::MQTT::Client.new(uri)
+      @client.connect
+      log("[CONNECTED] #{host}:#{port}", Logger::DEBUG)
+      return @client
+    end
+
+
+    # Check has connection.
+    # @return [Boolean]
+    def connected?
+      @client.present? and @client.connected?
+    end
+
+    # Generate OAuth header
+    # @param [String] uri Auth URI
+    # @param [String] consumer_key Auth consumer-key
+    # @param [String] consumer_secret Auth consumer-secret
+    # @param [Hash] options Auth options
+    def generate_oauth_header(uri, consumer_key, consumer_secret, options={})
+      init_opt = {client_credential_key: consumer_key, client_credential_secret: consumer_secret}
+      options[:uri] = uri if options[:uri].nil? or options[:uri].empty?
+      options[:method] = MQTT_METHOD
+      client = ::Signet::OAuth1::Client.new(init_opt)
+      client.two_legged = true
+      client, options = yield(client, options) if block_given?
+      req = client.generate_authenticated_request(options)
+      req["Authorization"]
+    end
+
+
+    # Validate arguments.
+    # @see initialize
+    def validate_args(args)
+      errors = []
+      args = args.symbolize_keys
+      OPTIONS.each do |key, val|
+        if val[:required]
+          errors << {field: key, message: "required param"} if args[key].blank?
+        end
+        if val[:default] and not args.key?(key)
+          args[key] = val[:default]
+        end
+      end
+      return args, errors
+    end
+
+    # Logging
+    # @param [String] message Logging message
+    # @param [Symbol|String] type Logging type
+    # @param [Symbol] colour Message color
+    def log(message="", lv=DEFAULT_LOG_LEVEL, colour=nil)
+      color = COLOURS[colour.to_s.downcase.to_sym]
+      m = ""
+      m << "#{color}" if color.present?
+      m << "#{message}"
+      m << "\e[0m" if color.present?
+      logger.log(lv, m) if logger
+    end
+
+
+    # Show errors and exit(0)
+    # @param [Array] errors Error messages
+    # @param [String] message Extra message
+    def show_errors(errors, message="")
+      errors.each do |e|
+        log("#{e[:field]}: #{e[:message]}", Logger::ERROR, :red)
+      end
+      log(message, Logger::INFO, :white) if message.present?
+    end
+
+    def initialize_usage
+      <<__USAGE__
+
+usage:
+
+c = Libmagellan::MQTT.new(host: "127.0.0.1", host: 1883, consumer_key: "groovenauts.app1", consumer_secret: "test", client_version: "0.0.1", log_level: :debug, commandline: true)
+
+__USAGE__
+    end
+
+    class MqttError < StandardError
+    end
+
+  end
+end

data/lib/libmagellan/version.rb

@@ -1,3 +1,3 @@
 module Libmagellan
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/libmagellan.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "signet", "~> 0.5.0"
   spec.add_runtime_dependency "activesupport"
+  spec.add_runtime_dependency "mqtt", "~> 0.3.1"
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake", "~> 10.0"

data/spec/libmagellan/http_spec.rb

@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Libmagellan::HTTP do
+  let(:lm){ Libmagellan::HTTP.new("http://localhost:3000", consumer_key: "foo", consumer_secret: "bar") }
+
+  describe :request do
+
+    let(:http){ double(:http) }
+    let(:res){ double(:res) }
+
+    before do
+      allow(Net::HTTP).to receive(:new).with("localhost", 3000).and_return(http)
+      allow(http).to receive(:start).and_yield(http)
+    end
+
+    describe :get do
+      it :success do
+        allow(http).to receive(:get).\
+          with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+          and_return(res)
+        r = lm.request("/ping")
+        expect(r).to eq res
+      end
+    end
+
+    describe :post do
+      it :success do
+        allow(http).to receive(:post).\
+          with("/ping", "param1=value1", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+          and_return(res)
+        r = lm.request("/ping", :post, "param1=value1")
+        expect(r).to eq res
+      end
+      it "accept Hash as body parameter" do
+        allow(http).to receive(:post).\
+          with("/ping", "param1=value1&param2=value2", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+          and_return(res)
+        r = lm.request("/ping", :post, {param1: "value1", param2: "value2"})
+        expect(r).to eq res
+      end
+    end
+
+    describe :put do
+      it :success do
+        allow(http).to receive(:put).\
+          with("/ping", "param1=value1&param2=value2", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+          and_return(res)
+        r = lm.request("/ping", :put, {param1: "value1", param2: "value2"})
+        expect(r).to eq res
+      end
+    end
+
+    describe :delete do
+      it :success do
+        allow(http).to receive(:delete).\
+          with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+          and_return(res)
+        r = lm.request("/ping", :delete)
+        expect(r).to eq res
+      end
+    end
+  end
+
+  describe :ping do
+
+    let(:http){ double(:http) }
+    let(:res){ double(:res) }
+
+    before do
+      allow(Net::HTTP).to receive(:new).with("localhost", 3000).and_return(http)
+      allow(http).to receive(:start).and_yield(http)
+    end
+
+    it :success do
+      allow(res).to receive(:code).and_return("200")
+      allow(res).to receive(:body).and_return("pong\n")
+      allow(http).to receive(:get).\
+        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+        and_return(res)
+      r = lm.test_ping
+      expect(r).to eq lm
+    end
+
+    it :connection_failure_1_time do
+      allow(http).to receive(:get).\
+        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+        once.\
+        and_raise(Errno::ECONNREFUSED)
+      allow(res).to receive(:code).and_return("200")
+      allow(res).to receive(:body).and_return("pong\n")
+      allow(http).to receive(:get).\
+        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+        and_return(res)
+      r = lm.test_ping
+      expect(r).to eq lm
+    end
+
+    it :connection_failure do
+      allow(http).to receive(:get).\
+        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+        exactly(3).times.\
+        and_raise(Errno::ECONNREFUSED)
+      expect{ lm.test_ping(max_retry_count: 2, retry_interval: 0) }.to raise_error(Errno::ECONNREFUSED)
+    end
+
+    it :error_response do
+      allow(res).to receive(:code).and_return("500")
+      allow(res).to receive(:body).and_return("Something wrong!")
+      allow(http).to receive(:get).\
+        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
+        and_return(res)
+      expect{ lm.test_ping }.to raise_error(Libmagellan::InvalidResponse)
+    end
+  end
+end

data/spec/libmagellan/mqtt_spec.rb

@@ -0,0 +1,85 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Libmagellan::MQTT do
+
+  let(:consumer_key) { "groovenauts.app1" }
+  let(:token){ "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" }
+  let(:lm) {
+    lm = Libmagellan::MQTT.new({host: "127.0.0.1",
+                                port: 1883,
+                                consumer_key: consumer_key,
+                                consumer_secret: "test",
+                                client_version: "0.0.1"
+                               })
+    lm.token = token
+    lm
+  }
+  let(:socket) do
+    socket = StringIO.new
+    if socket.respond_to?(:set_encoding)
+      socket.set_encoding("binary")
+    else
+      socket
+    end
+  end
+  let(:client){ MQTT::Client.new(:host => 'localhost') }
+
+
+
+  describe :publish do
+    before do
+      allow(TCPSocket).to receive(:new).and_return(socket)
+      allow(Thread).to receive(:new)
+      client.instance_variable_set('@socket', socket)
+      lm.instance_variable_set('@client', client)
+    end
+
+    it "is success" do
+      lm.publish("topic", "payload")
+      expect(socket.string).to eq("\x30\x0e\x00\x05topicpayload".b)
+    end
+  end
+
+
+  describe :subscribe do
+    before do
+      client.instance_variable_set('@socket', socket)
+      lm.instance_variable_set('@client', client)
+    end
+
+    it "is success" do
+      lm.subscribe('a/b')
+      expect(socket.string).to eq("\x82\x08\x00\x01\x00\x03a/b\x00".b)
+    end
+
+    it "is success" do
+      lm.subscribe(['a/b'])
+      expect(socket.string).to eq("\x82\x08\x00\x01\x00\x03a/b\x00".b)
+    end
+  end
+
+
+  describe :get do
+    before do
+      client.instance_variable_set('@socket', socket)
+      lm.instance_variable_set('@client', client)
+    end
+
+    it "is success" do
+      inject_packet(:topic => 'topic0', :payload => 'payload0', :qos => 0)
+      topic,payload = lm.get
+      expect(topic).to eq('topic0')
+      expect(payload).to eq('payload0')
+    end
+  end
+
+
+  private
+
+  def inject_packet(opts={})
+    packet = MQTT::Packet::Publish.new(opts)
+    client.instance_variable_get('@read_queue').push(packet)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libmagellan
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - akima
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-23 00:00:00.000000000 Z
+date: 2014-12-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: signet
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mqtt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -97,10 +111,13 @@ files:
 - Rakefile
 - bin/libmagellan
 - lib/libmagellan.rb
-- lib/libmagellan/base.rb
+- lib/libmagellan/core.rb
+- lib/libmagellan/http.rb
+- lib/libmagellan/mqtt.rb
 - lib/libmagellan/version.rb
 - libmagellan.gemspec
-- spec/libmagellan/base_spec.rb
+- spec/libmagellan/http_spec.rb
+- spec/libmagellan/mqtt_spec.rb
 - spec/libmagellan_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -128,7 +145,7 @@ signing_key:
 specification_version: 4
 summary: ruby client for magellanic cloud
 test_files:
-- spec/libmagellan/base_spec.rb
+- spec/libmagellan/http_spec.rb
+- spec/libmagellan/mqtt_spec.rb
 - spec/libmagellan_spec.rb
 - spec/spec_helper.rb
-has_rdoc: 

data/spec/libmagellan/base_spec.rb

@@ -1,72 +0,0 @@
-# -*- coding: utf-8 -*-
-require 'spec_helper'
-
-describe Libmagellan::Base do
-  let(:lm){ Libmagellan.new("http://localhost:3000", consumer_key: "foo", consumer_secret: "bar") }
-
-  describe :request do
-
-    let(:http){ double(:http) }
-    let(:res){ double(:res) }
-
-    it :success do
-      allow(Net::HTTP).to receive(:start).with("localhost", 3000).and_yield(http)
-      allow(http).to receive(:get).\
-      with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
-      and_return(res)
-      r = lm.request("/ping")
-      expect(r).to eq res
-    end
-  end
-
-  describe :ping do
-
-    let(:http){ double(:http) }
-    let(:res){ double(:res) }
-
-    it :success do
-      allow(Net::HTTP).to receive(:start).with("localhost", 3000).and_yield(http)
-      allow(res).to receive(:code).and_return("200")
-      allow(res).to receive(:body).and_return("pong\n")
-      allow(http).to receive(:get).\
-        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
-        and_return(res)
-      r = lm.test_ping
-      expect(r).to eq lm
-    end
-
-    it :connection_failure_1_time do
-      allow(Net::HTTP).to receive(:start).with("localhost", 3000).and_yield(http)
-      allow(http).to receive(:get).\
-        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
-        once.\
-        and_raise(Errno::ECONNREFUSED)
-      allow(res).to receive(:code).and_return("200")
-      allow(res).to receive(:body).and_return("pong\n")
-      allow(http).to receive(:get).\
-        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
-        and_return(res)
-      r = lm.test_ping
-      expect(r).to eq lm
-    end
-
-    it :connection_failure do
-      allow(Net::HTTP).to receive(:start).with("localhost", 3000).and_yield(http)
-      allow(http).to receive(:get).\
-        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
-        exactly(3).times.\
-        and_raise(Errno::ECONNREFUSED)
-      expect{ lm.test_ping(max_retry_count: 2, retry_interval: 0) }.to raise_error(Errno::ECONNREFUSED)
-    end
-
-    it :error_response do
-      allow(Net::HTTP).to receive(:start).with("localhost", 3000).and_yield(http)
-      allow(res).to receive(:code).and_return("500")
-      allow(res).to receive(:body).and_return("Something wrong!")
-      allow(http).to receive(:get).\
-        with("/ping", hash_including("Authorization" => an_instance_of(String), "Cache-Control" => "no-store", "Client-Version" => "0.0.1")).\
-        and_return(res)
-      expect{ lm.test_ping }.to raise_error(Libmagellan::InvalidResponse)
-    end
-  end
-end