bazil_client 1.0.0

data/.gitignore

@@ -0,0 +1,9 @@
+*.gem
+*.rbc
+.bundle
+.config
+Gemfile.lock
+/coverage/
+/vendor/bundle/
+/pkg/
+/rdoc/

data/ChangeLog.md

@@ -0,0 +1,3 @@
+## Version 1.0.0 (2013-02-14) ##
+
+Released!

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+gemspec
+
+gem "simplecov", :require => false
+gem 'rspec', :require => false

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Preferred Infrastructure,Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rubygems'
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rspec_opts = ['--color --backtrace']
+end
+
+task :default => [:spec]

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bazil_client.gemspec

@@ -0,0 +1,24 @@
+# encoding: utf-8
+$:.push File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "bazil_client"
+  gem.description = "Ruby client of Bazil"
+  gem.homepage    = "https://asp-bazil.preferred.jp/"
+  gem.summary     = gem.description
+  gem.version     = File.read("VERSION").strip
+  gem.authors     = ["Nobuyuki Kubota"]
+  gem.email       = "bazil-info@preferred.jp"
+  gem.has_rdoc    = false
+  gem.platform    = Gem::Platform::RUBY
+  gem.files       = `git ls-files`.split("\n")
+  gem.test_files  = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ['lib']
+  gem.license = "MIT"
+
+  gem.required_ruby_version = '>= 1.9.0'
+  gem.add_development_dependency "rake", ">= 0.9.2"
+  gem.add_development_dependency "simplecov", ">= 0.5.4"
+  gem.add_development_dependency "rspec", ">= 1.0.0"
+end

data/lib/bazil/client.rb

@@ -0,0 +1,159 @@
+require 'forwardable'
+
+require 'rubygems'
+require 'json'
+require 'net/http'
+require 'net/https'
+require 'bazil/model'
+require 'bazil/rest'
+require 'bazil/error'
+
+module Bazil
+  class Client
+    extend Forwardable
+
+    class Options
+      attr_reader :host, :port, :scheme, :ca_file, :ssl_version, :verify_mode
+
+      def initialize(options)
+        if options.kind_of? String
+          options = {CA_FILE_KEY => options}
+        end
+        options = symbolize_keys(options)
+
+        url = URI::parse(options[URL_KEY] || DEFAULT_URL)
+        @host = url.host or raise "Failed to obtain host name from given url: url = #{url.to_s}"
+        @port = url.port or raise "Failed to obtain port number from given url: url = #{url.to_s}"
+        @scheme = url.scheme or raise "Failed to obtain scheme from given url: url = #{url.to_s}"
+        raise "Unsupported scheme '#{@scheme}'" unless AVAILABLE_SCHEMA.include? @scheme
+
+        @ca_file = options[CA_FILE_KEY] || DEFAULT_CA_FILE
+        if @ca_file
+          raise "ca_file option must be string value" unless @ca_file.is_a? String
+          raise "ca_file option must be absolute path" unless @ca_file[0] == '/'
+          raise "ca_file '#{@ca_file}' doesn't exist" unless File::exists? @ca_file
+        end
+
+        ssl_version = options[SSL_VERSION_KEY] || DEFAULT_SSL_VERSION
+        raise "Unsupported SSL version '#{ssl_version}'" unless AVAILABLE_SSL_VERSIONS.has_key? ssl_version
+        @ssl_version = AVAILABLE_SSL_VERSIONS[ssl_version]
+
+        skip_verify = options[SKIP_VERIFY_KEY] || DEFAULT_SKIP_VERIFY
+        raise "skip_verify option must be boolean value" unless skip_verify.is_a?(TrueClass) || skip_verify.is_a?(FalseClass)
+        @verify_mode = skip_verify ?  OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        {}.tap{|new_hash|
+          hash.each{|k,v|
+            new_hash[k.to_s.to_sym] = v
+          }
+        }
+      end
+
+      URL_KEY = :url
+      DEFAULT_URL = 'https://asp-bazil.preferred.jp/'
+      AVAILABLE_SCHEMA = ['http', 'https']
+
+      CA_FILE_KEY = :ca_file
+      DEFAULT_CA_FILE = nil
+
+      SSL_VERSION_KEY = :ssl_version
+      AVAILABLE_SSL_VERSIONS = {SSLv3: 'SSLv3', TLSv1: 'TLSv1'}
+      DEFAULT_SSL_VERSION = :TLSv1
+
+      SKIP_VERIFY_KEY = :skip_verify
+      DEFAULT_SKIP_VERIFY = false
+    end
+
+    def set_ssl_options(http, options)
+      http.use_ssl = options.scheme == 'https'
+      http.ca_file = options.ca_file
+      http.ssl_version = options.ssl_version
+      http.verify_mode = options.verify_mode
+    end
+
+    def initialize(options={})
+      opt = Options.new(options)
+      http = Net::HTTP.new(opt.host, opt.port)
+      set_ssl_options(http,opt)
+      @http_cli = REST.new(http)
+    end
+
+    def_delegators :@http_cli, :read_timeout, :read_timeout=, :set_api_keys
+
+    def models(options = {})
+      queries = {}
+      queries[:tag_id] = options[:tag_id].to_i if options.has_key? :tag_id
+      queries[:page] = options[:page].to_i if options.has_key? :page
+      queries[:per_page] = options[:per_page].to_i if options.has_key? :per_page
+
+      res, body = @http_cli.get(gen_uri("models",queries))
+      raise_error("Failed to get models", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)["models"].map{|model|
+        model["config_ids"].map{|config_id|
+          Model.new(self, model["id"].to_i, config_id.to_i)
+        }
+      }.flatten
+    end
+
+    def create_model(config)
+      data = config.to_json
+      res, body = @http_cli.post(gen_uri('models'), data, {'Content-Type' => 'application/json; charset=UTF-8', 'Content-Length' => data.length.to_s})
+      raise_error("Failed to create model", res) unless res.code =~ /2[0-9][0-9]/ # TODO: return detailed error information
+      js = JSON.parse(res.body)
+      Model.new(self, js['model_id'].to_i, js['config_id'].to_i)
+    end
+
+    def delete_model(model_id)
+      res, body = @http_cli.delete(gen_uri("models/#{model_id}"))
+      raise_error("Failed to delete model", res) unless res.code =~ /2[0-9][0-9]/ # TODO: return detailed error information
+      JSON.parse(res.body)
+    end
+
+    def create_config(model_id, config)
+      data = config.to_json
+      res, body = @http_cli.post(gen_uri("models/#{model_id}/configs"), data, {'Content-Type' => 'application/json; charset=UTF-8', 'Content-Length' => data.length.to_s})
+      raise_error("Failed to create new configuration", res) unless res.code =~ /2[0-9][0-9]/ # TODO: return detailed error information
+      js = JSON.parse(res.body)
+      Model.new(self, model_id, js['config_id'].to_i)
+    end
+
+    def delete_config(model_id, config_id)
+      res, body = @http_cli.delete(gen_uri("models/#{model_id}/configs/#{config_id}"))
+      raise_error("Failed to delete configuration", res) unless res.code =~ /2[0-9][0-9]/ # TODO: return detailed error information
+      JSON.parse(res.body)
+    end
+
+    def model(model_id, config_id)
+      model = Model.new(self, model_id, config_id)
+      model.status
+      model
+    end
+
+    def http_client
+      @http_cli
+    end
+
+    # TODO: make this changable
+    def api_version
+      'v2'
+    end
+
+    private
+
+    def gen_uri(path, queries = {})
+      if queries.empty?
+        "/#{api_version}/#{path}"
+      else
+        "/#{api_version}/#{path}?#{queries.map{|k,v| "#{k}=#{v}"}.join('&')}"
+      end
+    end
+
+    def raise_error(message, res)
+      raise APIError.new(message, res.code, JSON.parse(res.body))
+    end
+  end # class Client
+end # module Bazil

data/lib/bazil/error.rb

@@ -0,0 +1,37 @@
+module Bazil
+  class BazilError < RuntimeError
+    def inspect
+      to_s
+    end
+  end
+
+  class ConnectionError < BazilError
+    attr_reader :method, :address, :port
+
+    def initialize(method, address, port)
+      @method = method
+      @address = address
+      @port = port
+    end
+
+    def to_s
+      "Failed to connect to the server at #{@method} method: server = #{@address}:#{@port}"
+    end
+  end
+
+  class APIError < BazilError
+    attr_reader :errors
+
+    def initialize(message, code, response)
+      @message = message
+      @code = code
+      @errors = response['errors']
+    end
+
+    def to_s
+      result = [@message]
+      result += @errors.map { |error| "\t#{error['file']}(#{error['line']}): #{error['ecode']}: #{error['message']}" }
+      result.join("\n")
+    end
+  end
+end

data/lib/bazil/model.rb

@@ -0,0 +1,180 @@
+require 'rubygems'
+require 'json'
+require 'bazil/error'
+
+module Bazil
+  class Model
+    attr_reader :model_id, :config_id
+
+    def initialize(client, model_id, config_id)
+      @client = client
+      @http_cli = client.http_client
+      @model_id = model_id
+      @config_id = config_id
+    end
+
+    def status
+      res = @http_cli.get(gen_uri(target_path(@config_id, "status")))
+      raise_error("Failed to get status of the model: #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)
+    end
+
+    def model_config
+      res = @http_cli.get(gen_uri())
+      raise_error("Failed to get model config: #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)
+    end
+
+    def update_model_config(conf)
+      res = @http_cli.put(gen_uri(), conf.to_json, {'Content-Type' => 'application/json; charset=UTF-8', 'Content-Length' => conf.to_json.length.to_s})
+      JSON.parse(res.body)
+    end
+
+    def config
+      res = @http_cli.get(gen_uri("configs/#{@config_id}"))
+      raise_error("Failed to get config of the model: #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)
+    end
+
+    def update_config(config)
+      res = send(:put, "configs/#{@config_id}", config.to_json, "Failed to updated config")
+      {}
+    end
+
+    def train(train_data)
+      train_data = symbolize_keys(train_data)
+      raise ArgumentError, 'Annotation must be not nil' unless train_data.has_key? :annotation
+      raise ArgumentError, 'Data must be not nil' unless train_data.has_key? :data
+
+      body = post("training_data", train_data.to_json, "Failed to post training data")
+      JSON.parse(body)
+    end
+
+    def retrain(option = {})
+      body = post(target_path(@config_id, 'retrain'), option.to_json, "Failed to retrain the model")
+      JSON.parse(body)
+    end
+
+    def trace(method, data, config = nil)
+      new_data = {}
+      new_data['method'] = method if method
+      new_data['data'] = data if data
+      new_data['config'] = config if config
+      body = post(target_path(@config_id, "trace"), new_data.to_json, "Failed to execute trace")
+      JSON.parse(body)
+    end
+
+    def evaluate(method, config = nil)
+      new_data = {}
+      new_data['method'] = method if method
+      new_data['config'] = config if config
+      body = post(target_path(@config_id, "evaluate"), new_data.to_json, "Failed to execute evaluate")
+      JSON.parse(body)
+    end
+
+    def labels
+      res = @http_cli.get(gen_uri(target_path(@config_id, "labels")))
+      raise_error("Failed to get labels the model has: #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)['labels']
+    end
+
+    def training_data(id)
+      raise ArgumentError, 'Id must be Integer' unless id.kind_of? Integer
+      res = @http_cli.get(gen_uri("training_data/#{id}"))
+      raise_error("Failed to get training data of the model: id = #{id}, #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)
+    end
+
+    def list_training_data(condition = {})
+      condition = condition.dup
+      condition[:page] ||= 1
+      condition[:per_page] ||= 10
+
+      res = @http_cli.get(gen_uri("training_data?page=#{condition[:page]}&per_page=#{condition[:per_page]}"))
+      raise_error("Failed to query training data of the model", res) unless res.code =~ /2[0-9][0-9]/
+      JSON.parse(res.body)
+    end
+
+    def delete_all_training_data
+      res = @http_cli.delete(gen_uri("training_data"))
+      raise_error("Failed to delete all training_data of the model: #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      {}
+    end
+
+    def put_training_data(new_data = {})
+      new_data = symbolize_keys(new_data)
+      raise ArgumentError, 'Data must be not nil' unless new_data.has_key? :data
+      body = post('training_data', new_data.to_json, "Failed to post training data")
+      JSON.parse(body)
+    end
+
+    def update_training_data(id, new_data = {})
+      new_data = symbolize_keys(new_data)
+      raise ArgumentError, 'Id must be Integer' unless id.kind_of? Integer
+      raise ArgumentError, 'Data must be not nil' unless new_data.has_key? :data
+      send(:put, "training_data/#{id}", new_data.to_json, "Failed to update training data")
+      {}
+    end
+
+    def delete_training_data(id)
+      raise ArgumentError, 'Id must be Integer' unless id.kind_of? Integer
+      res = @http_cli.delete(gen_uri("training_data/#{id}"))
+      raise_error("Failed to delete a training data: id = #{id}, #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/
+      {}
+    end
+
+    def query(data)
+      data = {'data' => data}.to_json
+      res = post(target_path(@config_id, 'query'), data, "Failed to post data for query")
+      JSON.parse(res)
+    end
+
+    private
+
+    def symbolize_keys(data)
+      {}.tap{|d|
+        data.each{|k,v|
+          d[k.to_sym] = v
+        }
+      }
+    end
+
+    def stringify_keys(data)
+      {}.tap{|d|
+        data.each{|k,v|
+          d[k.to_s] = v
+        }
+      }
+    end
+
+    def post(path, data, error_message)
+      send(:post, path, data, error_message)
+    end
+
+    def send(method, path, data, error_message)
+      res = @http_cli.method(method).call(gen_uri(path), data, {'Content-Type' => 'application/json; charset=UTF-8', 'Content-Length' => data.length.to_s})
+      raise_error("#{error_message}: #{error_suffix}", res) unless res.code =~ /2[0-9][0-9]/ # TODO: enhance error information
+      res.body
+    end
+
+    def target_path(id, path)
+      "configs/#{id}/#{path}"
+    end
+
+    def gen_uri(path = nil)
+      if path
+        "/#{@client.api_version}/models/#{@model_id}/#{path}"
+      else
+        "/#{@client.api_version}/models/#{@model_id}"
+      end
+    end
+
+    def error_suffix
+      "model = #{@model_id}"
+    end
+
+    def raise_error(message, res)
+      raise APIError.new(message, res.code, JSON.parse(res.body))
+    end
+  end # module Model
+end # module Bazil

data/lib/bazil/rest.rb

@@ -0,0 +1,78 @@
+require 'forwardable'
+
+require 'rubygems'
+require 'json'
+require 'time'
+require 'net/http'
+require 'digest/md5'
+
+module Bazil
+  class REST
+    extend Forwardable
+
+    def initialize(http)
+      @http = http
+    end
+
+    def_delegators :@http, :read_timeout, :read_timeout=
+
+    def set_api_keys(key, secret)
+      @api_key = key
+      @secret_key = secret
+      true
+    end
+
+    def get(uri)
+      uri, header = add_api_signature(uri, nil)
+      @http.get(uri, header)
+    rescue Errno::ECONNREFUSED => e
+      raise_error('GET')
+    end
+
+    def put(uri, data, header = {})
+      uri, header = add_api_signature(uri, data, header)
+      @http.put(uri, data, header)
+    rescue Errno::ECONNREFUSED => e
+      raise_error('PUT')
+    end
+
+    def post(uri, data, header = {})
+      uri, header = add_api_signature(uri, data, header)
+      @http.post(uri, data, header)
+    rescue Errno::ECONNREFUSED => e
+      raise_error('POST')
+    end
+
+    def delete(uri)
+      uri, header = add_api_signature(uri, nil)
+      @http.delete(uri, header)
+    rescue Errno::ECONNREFUSED => e
+      raise_error('DELETE')
+    end
+
+    private
+    def add_api_signature(uri, data, header = {})
+      return uri, header unless @api_key and @secret_key
+
+      base,param = uri.split('?',2)
+      current_time = Time.now.httpdate
+
+      signature = ''
+      signature = data.gsub(/\s/, '') if data
+      parameters = (param || "").split('&')
+      parameters << "api_key=#{@api_key}"
+      signature << parameters.sort.join()
+      signature << current_time
+      signature << @secret_key
+      parameters << "api_signature=#{Digest::MD5.hexdigest(signature)}"
+      base << '?'
+      base << parameters.join('&')
+
+      return base, header.merge({'Date' => current_time})
+    end
+
+    def raise_error(method)
+      raise ConnectionError.new(method, @http.address, @http.port)
+    end
+  end # class Rest
+end # module Bazil

data/lib/bazil.rb

@@ -0,0 +1 @@
+require 'bazil/client'

data/spec/bazil/client_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Bazil::Client do
+  describe Bazil::Client::Options, "with empty option provide default" do
+    let(:option) { Bazil::Client::Options.new({}) }
+
+    it "host name" do
+      expect(option.host).to eq('asp-bazil.preferred.jp')
+    end
+
+    it "port name" do
+      expect(option.port).to eq(443)
+    end
+
+    it "scheme" do
+      expect(option.scheme).to eq('https')
+    end
+
+    it "ca_file" do
+      expect(option.ca_file).to eq(nil)
+    end
+
+    it "ssl_version" do
+      expect(option.ssl_version).to eq('TLSv1')
+    end
+
+    it "verify_mode" do
+      expect(option.verify_mode).to eq(OpenSSL::SSL::VERIFY_PEER)
+    end
+  end
+
+  describe Bazil::Client::Options, "with all options can parse" do
+    let(:option) {
+      Bazil::Client::Options.new({
+        url: 'http://localhost:8080/',
+        ca_file: __FILE__, # always exists and absolute path
+        ssl_version: :SSLv3,
+        skip_verify: true
+      })
+    }
+
+    it "host name" do
+      expect(option.host).to eq('localhost')
+    end
+
+    it "port name" do
+      expect(option.port).to eq(8080)
+    end
+
+    it "scheme" do
+      expect(option.scheme).to eq('http')
+    end
+
+    it "ca_file" do
+      expect(option.ca_file).to eq(__FILE__)
+    end
+
+    it "ssl_version" do
+      expect(option.ssl_version).to eq('SSLv3')
+    end
+
+    it "skip_verify" do
+      expect(option.verify_mode).to eq(OpenSSL::SSL::VERIFY_NONE)
+    end
+  end
+
+  describe Bazil::Client::Options, "'s url" do
+    it "can derivate HTTP port number from http schema" do
+      option = Bazil::Client::Options.new(url: 'http://localhost/')
+      expect(option.port).to eq(80)
+    end
+
+    it "can derivate HTTPS port number from https schem" do
+      option = Bazil::Client::Options.new(url: 'https://localhost/')
+      expect(option.port).to eq(443)
+    end
+
+    it "can overwrite port number for http schema" do
+      option = Bazil::Client::Options.new(url: 'http://localhost:443/')
+      expect(option.port).to eq(443)
+    end
+
+    it "can overwrite port number for https schem" do
+      option = Bazil::Client::Options.new(url: 'https://localhost:80/')
+      expect(option.port).to eq(80)
+    end
+  end
+
+  describe Bazil::Client::Options, "will raise error for" do
+    it "invalid url" do
+      proc {
+        Bazil::Client::Options.new(url: 42)
+      }.should raise_error
+    end
+
+    it "empty url" do
+      proc {
+        Bazil::Client::Options.new(url: '')
+      }.should raise_error
+    end
+
+    it "invalid port" do
+      proc {
+        Bazil::Client::Options.new(url: 'http://localhost:ssl_port_please/')
+      }.should raise_error
+    end
+
+    it "unsupported scheme" do
+      proc {
+        Bazil::Client::Options.new(url: 'saitama://localhost:80/')
+      }.should raise_error
+    end
+
+    it "non string ca_file" do
+      proc {
+        Bazil::Client::Options.new(ca_file: 42)
+      }.should raise_error
+    end
+
+    it "relative ca_file" do
+      proc {
+        Bazil::Client::Options.new(ca_file: './' + File::basename(__FILE__))
+      }.should raise_error
+    end
+
+    it "non exists ca_file" do
+      proc {
+        Bazil::Client::Options.new(ca_file: '/:never:/:exist:/:file:/:path:')
+      }.should raise_error
+    end
+
+    it "invalid ssl_version" do
+      proc {
+        Bazil::Client::Options.new(ssl_version: 3.14)
+      }.should raise_error
+    end
+
+    it "unsupported ssl_version" do
+      proc {
+        Bazil::Client::Options.new(ssl_version: :SSL_version_saitama)
+      }.should raise_error
+    end
+
+    it "non-boolean skip_verify" do
+      proc {
+        Bazil::Client::Options.new(skip_verify: "YES")
+      }.should raise_error
+    end
+  end
+end

data/spec/bazil/model_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+class FakeResponse
+  attr_reader :code, :message, :body
+  def initialize(code,message,body)
+    @code = code
+    @message = message
+    @body = body
+  end
+end
+
+class FakeClient
+  attr_accessor :http_client
+  def initialize
+    @http_client = Object.new
+  end
+  def api_version
+    'v2'
+  end
+end
+
+describe Bazil::Client  do
+  let(:client) { FakeClient.new }
+  let(:model_id) { 42 }
+  let(:config_id) { 184 }
+
+  def gen_model_path(path = "")
+    "/#{client.api_version}/models/#{model_id}#{path}"
+  end
+
+  def gen_model_config_path(path = "")
+    "/#{client.api_version}/models/#{model_id}/configs/#{config_id}#{path}"
+  end
+
+  def header_for_json(js)
+    {
+      "Content-Type" => "application/json; charset=UTF-8",
+      "Content-Length" => js.to_json.length.to_s
+    }
+  end
+
+  let(:model) {
+    Bazil::Model.new(client, model_id, config_id)
+  }
+
+  describe "model" do
+    it "model_config send GET /models/:model_id" do
+      result = {}
+      client.http_client.should_receive(:get).with(gen_model_path("")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      res = model.model_config
+      expect(res).to eq(result)
+    end
+
+    it "update_model_config send PUT /models/:model_id" do
+      arg = {id: model_id, name: 'test'}
+      result = {}
+      client.http_client.should_receive(:put).with(gen_model_path(""), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      res = model.update_model_config(arg)
+      expect(res).to eq(result)
+    end
+
+    it "config send GET /models/:model_id/configs/:config_id" do
+      result = {}
+      client.http_client.should_receive(:get).with(gen_model_config_path("")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      res = model.config
+      expect(res).to eq(result)
+    end
+
+    it "update_config send PUT /models/:model_id/configs/:config_id" do
+      arg = {methd: 'arow', id: config_id, model_id: model_id}
+      result = {}
+      client.http_client.should_receive(:put).with(gen_model_config_path(""), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      res = model.update_config(arg)
+      expect(res).to eq(result)
+    end
+
+    it "status request GET /models/:model_id/configs/:config_id/status" do
+      result = { "num_features" => 0, "num_train_queries" => 0, "num_labels" => 0, "num_queries" => 0, }
+      client.http_client.should_receive(:get).with(gen_model_config_path("/status")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.status).to eq(result)
+    end
+
+    it "retrain with empty option request POST /models/:model_id/configs/:config_id/retrain" do
+      arg = {}
+      result = { "total" => 1000, "elapsed_time" => 0.5 }
+      client.http_client.should_receive(:post).with(gen_model_config_path("/retrain"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.retrain).to eq(result)
+    end
+
+    it "retrain with option request POST /models/:model_id/configs/:config_id/retrain" do
+      arg = {times: 10}
+      result = { "total" => 1000, "elapsed_time" => 0.5 }
+      client.http_client.should_receive(:post).with(gen_model_config_path("/retrain"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.retrain(arg)).to eq(result)
+    end
+
+    it "query request POST /models/:model_id/configs/:config_id/query" do
+      arg = {data: {key: "value"}}
+      result = { "score" => { "Label1" => 0.5, "Label2" => -0.5, }, "classifier_result" => "Label1", }
+      client.http_client.should_receive(:post).with(gen_model_config_path("/query"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.query(arg[:data])).to eq(result)
+    end
+
+    it "trace request POST /models/:model_id/configs/:config_id/trace" do
+      arg = {method: "feature_weights", data: {key: "value"}}
+      result = { "result" => { "Label1" => 0.5, "Label2" => -0.5, "feature_weights" => { } }, "data" => { "key" => "value" } }
+      client.http_client.should_receive(:post).with(gen_model_config_path("/trace"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.trace(arg[:method], arg[:data])).to eq(result)
+    end
+
+    it "evaluate request POST /models/:model_id/configs/:config_id/evaluate" do
+      arg = {method: "cross_validation", config: {num_folds: 2}}
+      result = { "folds" => [{},{}], "result" => {} }
+      client.http_client.should_receive(:post).with(gen_model_config_path("/evaluate"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.evaluate(arg[:method], arg[:config])).to eq(result)
+    end
+
+    it "put_training_data request POST /models/:model_id/training_data" do
+      arg = {data: {name: "P"}, annotation: "saitama"}
+      result = {"training_data_id" => 42}
+      client.http_client.should_receive(:post).with(gen_model_path("/training_data"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.put_training_data(arg)).to eq(result)
+    end
+
+    it "list_training_data request GET /models/:model_id/training_data and set default page information" do
+      result = { "num_training_data" => 1000, "page" => 1, "per_page" => 10, "training_data" => [] }
+      client.http_client.should_receive(:get).with(gen_model_path("/training_data?page=1&per_page=10")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.list_training_data).to eq(result)
+    end
+
+    it "list_training_data with page information request GET /models/:model_id/training_data" do
+      arg = {page: 100, per_page: 450}
+      result = { "num_training_data" => 1000, "page" => 1, "per_page" => 10, "training_data" => [] }
+      client.http_client.should_receive(:get).with(gen_model_path("/training_data?page=#{arg[:page]}&per_page=#{arg[:per_page]}")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.list_training_data(arg)).to eq(result)
+    end
+
+    it "delete_all_training_data request DELETE /models/:model_id/training_data" do
+      result = {}
+      client.http_client.should_receive(:delete).with(gen_model_path("/training_data")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.delete_all_training_data).to eq(result)
+    end
+
+    it "training_data request GET /models/:model_id/training_data/:training_data_id" do
+      training_data_id = 123
+      result = {"data" => {"name" => "P"}, "annotation" => "saitama"}
+      client.http_client.should_receive(:get).with(gen_model_path("/training_data/#{training_data_id}")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.training_data(training_data_id)).to eq(result)
+    end
+
+    it "update_training_data request PUT /models/:model_id/training_data/:training_data_id" do
+      training_data_id = 123
+      arg = {data: {name: "P"}, annotation: "gunnma"}
+      result = {}
+      client.http_client.should_receive(:put).with(gen_model_path("/training_data/#{training_data_id}"), arg.to_json, header_for_json(arg)).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.update_training_data(training_data_id, arg)).to eq(result)
+    end
+
+    it "delete_all_training_data request DELETE /models/:model_id/training_data/:training_data_id" do
+      training_data_id = 123
+      result = {}
+      client.http_client.should_receive(:delete).with(gen_model_path("/training_data/#{training_data_id}")).and_return(FakeResponse.new("200", "OK", result.to_json))
+      expect(model.delete_training_data(training_data_id)).to eq(result)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+  add_filter 'vendor/bundle'
+end
+
+require 'rubygems'
+require 'bazil'
+require 'net/http'
+require 'rspec'
+require 'rspec/mocks'

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: bazil_client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Nobuyuki Kubota
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.5.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+description: Ruby client of Bazil
+email: bazil-info@preferred.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- ChangeLog.md
+- Gemfile
+- LICENSE
+- README
+- Rakefile
+- VERSION
+- bazil_client.gemspec
+- lib/bazil.rb
+- lib/bazil/client.rb
+- lib/bazil/error.rb
+- lib/bazil/model.rb
+- lib/bazil/rest.rb
+- spec/bazil/client_spec.rb
+- spec/bazil/model_spec.rb
+- spec/spec_helper.rb
+homepage: https://asp-bazil.preferred.jp/
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -4262472802805615291
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Ruby client of Bazil
+test_files:
+- spec/bazil/client_spec.rb
+- spec/bazil/model_spec.rb
+- spec/spec_helper.rb