mushikago-sdk 0.4.3 → 2.0.0

data/lib/mushikago/hanamgri/training_data.rb

@@ -0,0 +1,27 @@
+# -*- coding : utf-8 -*-
+require 'json'
+module Mushikago
+  module Hanamgri
+    class TrainingData
+      attr_reader :training_data
+      
+      def initialize(&block)
+        @training_data = {}
+        instance_eval(&block) if block_given?
+      end
+      
+      def []= key, value
+        @training_data[key] = value
+      end
+
+      def put key, value
+        @training_data[key] = value
+      end
+
+      def to_json *args
+        @training_data.to_json(args)
+      end
+    end
+  end
+end
+

data/lib/mushikago/hanamgri/update_domain_request.rb

@@ -0,0 +1,18 @@
+# -*- coding : utf-8 -*-
+module Mushikago
+  module Hanamgri
+    class UpdateDomainRequest < Mushikago::Http::PostRequest
+      def path; "/1/hanamgri/domains/#{domain_name}" end
+      attr_accessor :domain_name
+      request_parameter :description
+
+      def initialize domain_name, description, options={}
+        super(options)
+        self.domain_name = domain_name
+        self.description = description
+      end
+    end
+  end
+end
+
+

data/lib/mushikago/hanamgri.rb

@@ -0,0 +1,30 @@
+# -*- coding : utf-8 -*-
+module Mushikago
+  module Hanamgri
+    autoload :Client, 'mushikago/hanamgri/client'
+
+    autoload :CreateDomainRequest, 'mushikago/hanamgri/create_domain_request'
+    autoload :DeleteDomainRequest, 'mushikago/hanamgri/delete_domain_request'
+    autoload :RequestAnalysisRequest, 'mushikago/hanamgri/request_analysis_request'
+    autoload :GetAnalysisRequest, 'mushikago/hanamgri/get_analysis_request'
+    autoload :GetQueueSizeRequest, 'mushikago/hanamgri/get_queue_size_request'
+    autoload :GetInformationRequest, 'mushikago/hanamgri/get_information_request'
+    autoload :GetListDomainsRequest, 'mushikago/hanamgri/list_domains_request'
+    autoload :UpdateDomainRequest, 'mushikago/hanamgri/update_domain_request'
+    autoload :GetListAnalysesRequest, 'mushikago/hanamgri/list_analyses_request'
+    autoload :SearchSchemaRequest, 'mushikago/hanamgri/search_schema_request'
+    autoload :TrainRequest, 'mushikago/hanamgri/train_request'
+    autoload :SaveDictionaryRequest, 'mushikago/hanamgri/save_dictionary_request'
+    autoload :ListDictionariesRequest, 'mushikago/hanamgri/list_dictionaries_request'
+    autoload :DeleteDictionaryRequest, 'mushikago/hanamgri/delete_dictionary_request'
+    autoload :SaveKnowledgeRequest, 'mushikago/hanamgri/save_knowledge_request'
+    autoload :ListKnowledgesRequest, 'mushikago/hanamgri/list_knowledges_request'
+    autoload :DeleteKnowledgeRequest, 'mushikago/hanamgri/delete_knowledge_request'
+    
+    autoload :Schema, 'mushikago/hanamgri/schema'
+    autoload :Field, 'mushikago/hanamgri/field'
+    
+    autoload :TrainingData, 'mushikago/hanamgri/training_data'
+  end
+end
+

data/lib/mushikago/version.rb

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 module Mushikago
   # Mushikago SDK for Ruby のバージョン
-  VERSION = '0.4.3'
+  VERSION = '2.0.0'
 end

data/lib/mushikago.rb

@@ -10,6 +10,7 @@ module Mushikago
   autoload :Tombo, 'mushikago/tombo'
   autoload :Hotaru, 'mushikago/hotaru'
   autoload :Mitsubachi, 'mushikago/mitsubachi'
+  autoload :Hanamgri, 'mushikago/hanamgri'
 
   # @return [Mushikago::Config] config コンフィグのインスタンスへのアクセスを提供する
   def self.config

data/spec/mushikago/hanamgri/client_spec.rb

@@ -0,0 +1,61 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::Client do
+  subject{ Mushikago::Hanamgri::Client.new }
+  it{ should be_respond_to(:create_domain) }
+  it{ should be_respond_to(:delete_domain) }
+  it{ should be_respond_to(:request_analysis) }
+  it{ should be_respond_to(:get_analysis) }
+  it{ should be_respond_to(:get_queue_size) }
+  it{ should be_respond_to(:get_information) }
+  it{ should be_respond_to(:list_domains) }
+  it{ should be_respond_to(:update_domain) }
+  it{ should be_respond_to(:list_analyses) }
+  it{ should be_respond_to(:search_schema) }
+  it{ should be_respond_to(:train) }
+  it{ should be_respond_to(:save_dictionary) }
+  it{ should be_respond_to(:list_dictionaries) }
+  it{ should be_respond_to(:delete_dictionary) }
+  it{ should be_respond_to(:save_knowledge) }
+  it{ should be_respond_to(:list_knowledges) }
+  it{ should be_respond_to(:delete_knowledge) }
+
+  [
+    [:create_domain, Mushikago::Hanamgri::CreateDomainRequest, ['domain_name', 'seeds', Mushikago::Hanamgri::Schema.new, {}]],
+    [:delete_domain, Mushikago::Hanamgri::DeleteDomainRequest, ['domain_name', {}]],
+    [:request_analysis, Mushikago::Hanamgri::RequestAnalysisRequest, ['domain_name', 'url', {}]],
+    [:get_analysis, Mushikago::Hanamgri::GetAnalysisRequest, ['domain_name', 'request_id', {}]],
+    [:get_queue_size, Mushikago::Hanamgri::GetQueueSizeRequest, ['domain_name', {}]],
+    [:get_information, Mushikago::Hanamgri::GetInformationRequest, ['domain_name', {}]],
+    [:list_domains, Mushikago::Hanamgri::GetListDomainsRequest, [{}]],
+    [:update_domain, Mushikago::Hanamgri::UpdateDomainRequest, ['domain_name', 'description', {}]],
+    [:list_analyses, Mushikago::Hanamgri::GetListAnalysesRequest, ['domain_name', {:limit => 20, :offset => 5, :status => 'complete'}]],
+    [:search_schema, Mushikago::Hanamgri::SearchSchemaRequest, ['domain_name', 'query_key', 'query_value', {:limit => 20, :offset => 5}]],
+    [:train, Mushikago::Hanamgri::TrainRequest, ['domain_name', 'http://www.mushikago.org/', Mushikago::Hanamgri::TrainingData.new, {}]],
+    [:save_dictionary, Mushikago::Hanamgri::SaveDictionaryRequest, ['domain_name', {:description => '辞書の説明'}]],
+    [:list_dictionaries, Mushikago::Hanamgri::ListDictionariesRequest, [{:limit => 3, :offset => 2}]],
+    [:delete_dictionary, Mushikago::Hanamgri::DeleteDictionaryRequest, ['dictionary_name', {}]],
+    [:save_knowledge, Mushikago::Hanamgri::SaveKnowledgeRequest, ['domain_name', {:description => '学習データの説明'}]],
+    [:list_knowledges, Mushikago::Hanamgri::ListKnowledgesRequest, [{:limit => 3, :offset => 2, :status => 'complete'}]],
+    [:delete_knowledge, Mushikago::Hanamgri::DeleteKnowledgeRequest, ['knowledge_name', {}]],
+  ].each do |method_name, clazz, args|
+    context method_name do
+      it "が呼ばれたとき、#{clazz}のインスタンスが生成され、send_requestに渡される" do
+        client, mock = create_client_and_request_mock
+        clazz.should_receive(:new).with(*args).and_return(mock)
+        client.send(method_name, *args)
+      end
+    end
+  end
+
+  # ====================================
+  # define helpers 
+  def create_client_and_request_mock
+    request_mock = Object.new
+    client = Mushikago::Hanamgri::Client.new
+    client.should_receive(:send_request).with(request_mock)
+    return [client, request_mock]
+  end
+end
+

data/spec/mushikago/hanamgri/create_domain_spec.rb

@@ -0,0 +1,34 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::CreateDomainRequest do
+  before :all do
+    @schema = Mushikago::Hanamgri::Schema.new do
+      add Mushikago::Hanamgri::Field.new('name', true, :string)
+      add Mushikago::Hanamgri::Field.new('price', true, :number, 'mushikago/ec/price')
+      add Mushikago::Hanamgri::Field.new('shipping', false, :string)
+      add Mushikago::Hanamgri::Field.new('description', false, :string)
+    end
+  end
+
+  shared_examples_for 'a valid request instance' do |n, s, o|
+    subject{ Mushikago::Hanamgri::CreateDomainRequest.new(n, s, @schema, o) }
+    it{ should be_kind_of(Mushikago::Http::PutRequest) }
+    its(:path){ should == "/1/hanamgri/domains/#{n}" }
+    its(:domain_name){ should == n }
+    its(:seeds){ should == s }
+    its(:schema){ should == @schema.to_json }
+    its(:description){ should == o[:description] }
+    its(:dictionary_name){ should == o[:dictionary_name] }
+  end
+
+  test_parameters = [
+    ['domain_name', 'seeds', {}],
+    ['name', 'seeds', {:description => 'description', :dictionary_name => 'dictionary'}],
+  ].each do |n, s, o|
+    context ".new(#{n}, #{s}, #{o})" do
+      it_should_behave_like 'a valid request instance', n, s, o
+    end
+  end
+end
+

data/spec/mushikago/hanamgri/delete_dictionary_spec.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::DeleteDictionaryRequest do
+  context '.new("domain_name")' do
+    subject{ Mushikago::Hanamgri::DeleteDictionaryRequest.new('dictionary_name')}
+    it{ should be_kind_of(Mushikago::Http::DeleteRequest)}
+    its(:dictionary_name){ should == 'dictionary_name'}
+    its(:path){ should == '/1/hanamgri/dictionary'}
+  end
+end

data/spec/mushikago/hanamgri/delete_domain_spec.rb

@@ -0,0 +1,12 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::DeleteDomainRequest do
+  context '.new("domain_name")' do
+    subject{ Mushikago::Hanamgri::DeleteDomainRequest.new('domain_name') }
+    it{ should be_kind_of(Mushikago::Http::DeleteRequest) }
+    its(:domain_name){ should == 'domain_name' }
+    its(:path){ should == '/1/hanamgri/domains/domain_name' }
+  end
+end
+

data/spec/mushikago/hanamgri/delete_knowledge_request_spec.rb

@@ -0,0 +1,11 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::DeleteKnowledgeRequest do
+  context '.new("domain_name")' do
+    subject{ Mushikago::Hanamgri::DeleteKnowledgeRequest.new('knowledge_name')}
+    it{ should be_kind_of(Mushikago::Http::DeleteRequest)}
+    its(:knowledge_name){ should == 'knowledge_name'}
+    its(:path){ should == '/1/hanamgri/knowledge'}
+  end
+end

data/spec/mushikago/hanamgri/field_spec.rb

@@ -0,0 +1,44 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::Field do
+  shared_examples_for 'a json serializable struct' do |n, r, t, k|
+    its(:name){ should == n }
+    its(:required){ should == r }
+    its(:type){ should == t }
+    its(:to_json){ should == {:name => n, :required => r, :type => t, :knowledge_name => k}.to_json }
+  end
+
+  context 'construct with' do
+    [
+      ['name', true, :string],
+      ['価格', true, :number],
+      ['shipping', false, :number],
+      ['説明', false, :string],
+      ['name', true, :string, 'mushikago/ec/title'],
+    ].each do |n, r, t, k|
+      context "(name:#{n} required:#{r} type:#{t} knowledge_name:#{k})" do
+        subject{ Mushikago::Hanamgri::Field.new(n, r, t, k) }
+        it_should_behave_like 'a json serializable struct', n, r, t, k
+        it('should validate') do
+          proc{ subject.validate! }.should_not raise_error
+        end
+      end
+    end
+    
+    [
+      ['name', true, :double],
+      ['価格', true, :float],
+      ['shipping', false, :object],
+      ['説明', false, :null],
+    ].each do |n, r, t, k|
+      context "(name:#{n} required:#{r} type:#{t}) knowledge_name#{k}" do
+        subject{ Mushikago::Hanamgri::Field.new(n, r, t, k) }
+        it_should_behave_like 'a json serializable struct', n, r, t, k
+        it('should not validate') do
+          proc{ subject.validate! }.should raise_error
+        end
+      end
+    end
+  end
+end

data/spec/mushikago/hanamgri/get_analysis_request_spec.rb

@@ -0,0 +1,12 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::GetAnalysisRequest do
+  context '.new("domain_name", "request_id")' do
+    subject{ Mushikago::Hanamgri::GetAnalysisRequest.new('domain_name', 'request_id')}
+    it{ should be_kind_of(Mushikago::Http::GetRequest)}
+    its(:domain_name){ should == 'domain_name'}
+    its(:request_id){ should == 'request_id'}
+    its(:path){ should == '/1/hanamgri/domains/domain_name/analyses/request_id'}
+  end
+end

data/spec/mushikago/hanamgri/get_information_request_spec.rb

@@ -0,0 +1,14 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+describe Mushikago::Hanamgri::GetInformationRequest do
+  domain_name = 'domain_name'
+  path = "/1/hanamgri/domains/#{domain_name}"
+  
+  context 'のインスタンス' do
+    subject{ Mushikago::Hanamgri::GetInformationRequest.new(domain_name)}
+    it{ should be_kind_of(Mushikago::Http::GetRequest)}
+    its(:path){ should == path }
+    its(:domain_name){ should == domain_name }
+  end
+  
+end

data/spec/mushikago/hanamgri/get_queue_size_request_spec.rb

@@ -0,0 +1,10 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+describe Mushikago::Hanamgri::GetQueueSizeRequest do
+  context 'のインスタンス' do
+    subject{ Mushikago::Hanamgri::GetQueueSizeRequest.new('domain_name')}
+    it{ should be_kind_of(Mushikago::Http::GetRequest)}
+    its(:path){ should == '/1/hanamgri/domains/domain_name/queues'}
+    its(:domain_name){ should == 'domain_name'}
+  end
+end

data/spec/mushikago/hanamgri/list_analyses_spec.rb

@@ -0,0 +1,25 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::GetListAnalysesRequest do
+  shared_examples_for 'a valid request instance for list_analyses' do |n, o|
+    subject{ Mushikago::Hanamgri::GetListAnalysesRequest.new(n, o) }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:path){ should == "/1/hanamgri/domains/#{n}/analyses" }
+    its(:domain_name){ should == n }
+    its(:limit){ should == o[:limit] }
+    its(:offset){ should == o[:offset] }
+    its(:filter){ should == o[:filter] }
+    its(:status){ should == o[:status] }
+  end
+
+  test_parameters = [
+    ['domain_name', {}],
+    ['name', {:limit => 20, :offset => 5, :status => 'complete'}],
+  ].each do |n, o|
+    context ".new(#{n}, #{o})" do
+      it_should_behave_like 'a valid request instance for list_analyses', n, o
+    end
+  end
+end
+

data/spec/mushikago/hanamgri/list_dictionaries_spec.rb

@@ -0,0 +1,19 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::ListDictionariesRequest do
+  context '.new()' do
+    subject{ Mushikago::Hanamgri::ListDictionariesRequest.new() }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:path){ should == '/1/hanamgri/dictionaries' }
+  end
+
+  context '.new(:limit => 20, :offset => 10)' do
+    subject{ Mushikago::Hanamgri::ListDictionariesRequest.new(:limit => 20, :offset => 10) }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:limit){ should == 20 }
+    its(:offset){ should == 10 }
+  end
+end
+
+

data/spec/mushikago/hanamgri/list_domains_spec.rb

@@ -0,0 +1,19 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::GetListDomainsRequest do
+  context '.new()' do
+    subject{ Mushikago::Hanamgri::GetListDomainsRequest.new() }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:path){ should == '/1/hanamgri/domains' }
+  end
+
+  context '.new(:limit => 20, :offset => 10,:filter => "domain")' do
+    subject{ Mushikago::Hanamgri::GetListDomainsRequest.new(:limit => 20, :offset => 10,:filter => 'domain') }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:limit){ should == 20 }
+    its(:offset){ should == 10 }
+    its(:filter){ should == 'domain' }
+  end
+end
+

data/spec/mushikago/hanamgri/list_knowledges_request_spec.rb

@@ -0,0 +1,20 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::ListKnowledgesRequest do
+  context '.new()' do
+    subject{ Mushikago::Hanamgri::ListKnowledgesRequest.new() }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:path){ should == '/1/hanamgri/knowledges' }
+  end
+
+  context '.new(:limit => 20, :offset => 10, :status => "complete")' do
+    subject{ Mushikago::Hanamgri::ListKnowledgesRequest.new(:limit => 20, :offset => 10, :status => "complete") }
+    it{ should be_kind_of(Mushikago::Http::GetRequest) }
+    its(:limit){ should == 20 }
+    its(:offset){ should == 10 }
+    its(:status){ should == "complete" }
+  end
+end
+
+

data/spec/mushikago/hanamgri/request_analysis_request_spec.rb

@@ -0,0 +1,21 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::RequestAnalysisRequest do
+  context '.new("domain_name", "url")' do
+    subject{ Mushikago::Hanamgri::RequestAnalysisRequest.new('domain_name', 'url') }
+    it{ should be_kind_of(Mushikago::Http::PutRequest) }
+    its(:domain_name){ should == 'domain_name' }
+    its(:url){ should == 'url' }
+    its(:path){ should == '/1/hanamgri/domains/domain_name/analysis' }
+  end
+
+  context '.new("domain_name", "url", :charset => "utf-8", :tag => "tag")' do
+    subject{ Mushikago::Hanamgri::RequestAnalysisRequest.new('domain_name', 'url', :charset => 'utf-8', :tag => 'tag') }
+    it{ should be_kind_of(Mushikago::Http::PutRequest) }
+    its(:domain_name){ should == 'domain_name' }
+    its(:url){ should == 'url' }
+    its(:charset){ should == 'utf-8' }
+    its(:tag){ should == 'tag' }
+  end
+end

data/spec/mushikago/hanamgri/save_dictionary_request_spec.rb

@@ -0,0 +1,22 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::SaveDictionaryRequest do
+  shared_examples_for 'a valid request instance for save_dictionary' do |n, o|
+    subject{ Mushikago::Hanamgri::SaveDictionaryRequest.new(n, o) }
+    it{ should be_kind_of(Mushikago::Http::PutRequest) }
+    its(:path){ should == "/1/hanamgri/dictionary" }
+    its(:domain_name){ should == n }
+    its(:description){ should == o[:description] }
+  end
+
+  test_parameters = [
+    ['domain_name', {}],
+    ['name', {:description => '辞書の説明'}],
+  ].each do |n, o|
+    context ".new(#{n}, #{o})" do
+      it_should_behave_like 'a valid request instance for save_dictionary', n, o
+    end
+  end
+end
+

data/spec/mushikago/hanamgri/save_knowledge_request_spec.rb

@@ -0,0 +1,22 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::SaveKnowledgeRequest do
+  shared_examples_for 'a valid request instance for save_knowledge' do |n, o|
+    subject{ Mushikago::Hanamgri::SaveKnowledgeRequest.new(n, o) }
+    it{ should be_kind_of(Mushikago::Http::PutRequest) }
+    its(:path){ should == "/1/hanamgri/knowledge" }
+    its(:domain_name){ should == n }
+    its(:description){ should == o[:description] }
+  end
+
+  test_parameters = [
+    ['domain_name', {}],
+    ['name', {:description => '学習データの説明'}],
+  ].each do |n, o|
+    context ".new(#{n}, #{o})" do
+      it_should_behave_like 'a valid request instance for save_knowledge', n, o
+    end
+  end
+end
+

data/spec/mushikago/hanamgri/schema_spec.rb

@@ -0,0 +1,53 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::Schema do
+  valid_examples = [
+    Mushikago::Hanamgri::Field.new('name', true, :string),
+    Mushikago::Hanamgri::Field.new('price', true, :number),
+    Mushikago::Hanamgri::Field.new('price', true, :number, 'mushikago/ec/price'),
+    {:name => 'name', :required => true, :type => :string},
+    {:name => 'price', :required => true, :type => :number},
+    {:name => 'price', :required => true, :type => :number, :knowledge_name => 'mushikago/ec/price'},
+  ]
+
+  valid_examples.each do |field|
+    context "adding valid field of #{field.class} #{field.to_json}" do
+      it 'should success adding field' do
+        proc{ Mushikago::Hanamgri::Schema.new.add field }.should_not raise_error
+      end
+    end
+  end
+
+  it '.new can take a block' do
+    proc do
+      Mushikago::Hanamgri::Schema.new do
+        valid_examples.each do |field|
+          add field
+        end
+      end
+    end.should_not raise_error
+  end
+
+  it '.to_json format is valid' do
+    instance = Mushikago::Hanamgri::Schema.new do
+      add valid_examples[0]
+      add valid_examples[1]
+    end
+    instance.to_json.should == {:fields => valid_examples[0,2]}.to_json
+  end
+  
+  invalid_examples = [
+    Mushikago::Hanamgri::Field.new('name', true, :double),
+    Mushikago::Hanamgri::Field.new('price', true, :boolean),
+    {:name => 'name', :required => true, :type => :object},
+    {:name => 'price', :required => true, :type => :hogehoge},
+  ]
+  invalid_examples.each do |field|
+    context "adding invalid field of #{field.class} #{field.to_json}" do
+      it 'should not success adding field' do
+        proc{ Mushikago::Hanamgri::Schema.new.add field }.should raise_error
+      end
+    end
+  end
+end

data/spec/mushikago/hanamgri/search_schema_request_spec.rb

@@ -0,0 +1,22 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::SearchSchemaRequest do
+  shared_examples_for 'a valid request instance for search_schema' do |n, k, v, o|
+    subject{ Mushikago::Hanamgri::SearchSchemaRequest.new(n, k, v, o)}
+    it{ should be_kind_of(Mushikago::Http::GetRequest)}
+    its(:path){ should == "/1/hanamgri/domains/#{n}/schema/search"}
+    its(:domain_name){ should == n }
+    its(:query_key){ should == k }
+    its(:query_value){ should == v }
+  end
+  
+  test_parameters = [
+    ['domain_name', 'query_key', 'query_value', {}],
+    ['name', 'key', 'value', {}],
+  ].each do |n, k, v, o|
+    context ".new(#{n}, #{k}, #{v}, #{o})" do
+      it_should_behave_like 'a valid request instance for search_schema', n, k, v, o
+    end
+  end
+end

data/spec/mushikago/hanamgri/train_spec.rb

@@ -0,0 +1,31 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::TrainRequest do
+  before :all do
+    @training_data = Mushikago::Hanamgri::TrainingData.new do
+      put("name", "株式会社マイニングブラウニー")
+      put("address", "東京都中央区日本橋浜町１−２−３")
+      put("tel", "03-6206-2812")
+    end
+  end
+
+  shared_examples_for 'a valid train instance' do |domain_name, url_or_html|
+    subject{ Mushikago::Hanamgri::TrainRequest.new(domain_name, url_or_html, @training_data) }
+    it{ should be_kind_of(Mushikago::Http::PostRequest) }
+    its(:path){ should == "/1/hanamgri/domains/#{domain_name}/train" }
+    its(:domain_name){ should == domain_name }
+    its(:url_or_html){ should == url_or_html }
+    its(:training_data){ should == @training_data.to_json }
+  end
+
+  test_parameters = [
+    ['domain_name', 'http://www.mushikago.org'],
+    ['domain_name', '<div>hello mushikago</div>'],
+  ].each do |domain_name, url|
+    context ".new(#{domain_name}, #{url})" do
+      it_should_behave_like 'a valid train instance', domain_name, url
+    end
+  end
+end
+

data/spec/mushikago/hanamgri/update_domain_spec.rb

@@ -0,0 +1,22 @@
+# -*- coding : utf-8 -*-
+require 'spec_helper'
+
+describe Mushikago::Hanamgri::UpdateDomainRequest do
+  shared_examples_for ' a valid request instance for update_domain' do |n, d, o|
+    subject{ Mushikago::Hanamgri::UpdateDomainRequest.new(n, d, o) }
+    it{ should be_kind_of(Mushikago::Http::PostRequest) }
+    its(:path){ should == "/1/hanamgri/domains/#{n}" }
+    its(:domain_name){ should == n }
+    its(:description){ should == d }
+  end
+
+  test_parameters = [
+    ['domain_name', 'description', {}],
+    ['name', 'description', {}],
+  ].each do |n, d, o|
+    context ".new(#{n}, #{d}, #{o})" do
+      it_should_behave_like ' a valid request instance for update_domain', n, d, o
+    end
+  end
+end
+