dymos 0.1.4 → 0.2.0

data/spec/lib/dymos/query/put_item_spec.rb

@@ -1,319 +1,63 @@
 describe Dymos::Query::PutItem do
-  before :all do
-    Aws.config[:region] = 'us-west-1'
-    Aws.config[:endpoint] = 'http://localhost:4567'
-    Aws.config[:access_key_id] = 'XXX'
-    Aws.config[:secret_access_key] = 'XXX'
-
-    client = Aws::DynamoDB::Client.new
-    client.delete_table(table_name: 'test_put_item') if client.list_tables[:table_names].include?('test_put_item')
-    client.create_table(
-        table_name: 'test_put_item',
-        attribute_definitions: [
-            {attribute_name: 'id', attribute_type: 'S'},
-        ],
-        key_schema: [
-            {attribute_name: 'id', key_type: 'HASH'}
-        ],
-        provisioned_throughput: {
-            read_capacity_units: 1,
-            write_capacity_units: 1,
-        })
-    client.put_item(table_name: 'test_put_item', item: {id: 'hoge', name: '太郎'})
-    client.put_item(table_name: 'test_put_item', item: {id: 'fuga', category_id: 1})
-
-    class TestItem < Dymos::Model
-      table :test_put_item
-      field :id, :string
-      field :name, :string
+  describe 'build query', order: :defined do
+    let(:builder) { Dymos::Query::PutItem.new }
+    let(:table) { 'test_put_item_table' }
+
+    it do
+      @client.delete_table(table_name: table) if @client.list_tables[:table_names].include?(table)
+      query=Dymos::Query::CreateTable.new.name(table).attributes(id: 'S').keys(id: 'HASH').build
+      @client.create_table(query)
+      @client.put_item(table_name: table, item: {id: 'hoge', param1: 101, param2: 201, param3: "hoge", param4: [1, 0, 1]})
+      @client.put_item(table_name: table, item: {id: 'fuga', param1: 102, param2: 202, param3: "fuga", param4: [1, 0, 2]})
+      @client.put_item(table_name: table, item: {id: 'piyo', param1: 103, param2: 203, param3: "piyo", param4: [1, 0, 3]})
     end
-  end
 
-  let(:client) { Aws::DynamoDB::Client.new }
-  describe :put_item do
-    describe "クエリ生成" do
-      it "追加のみ" do
-        query = TestItem.put.item(id: "foo", name: "John")
-        expect(query.query).to eq({
-                                      table_name: "test_put_item",
-                                      item: {id: "foo", name: "John"},
-                                      return_values: "ALL_OLD",
-                                  })
-      end
+    it :create do
+      data={id: 'poyo', param1: 104, param2: 204, param3: "poyo", param4: [1, 0, 4]}
+      builder.name(table).item(data).return_values(:ALL_OLD)
+      result = @client.put_item builder.build
+      expect(result.error).to eq(nil)
+      expect(result.attributes).to eq(nil)
 
-    end
-    it "条件なしput_item実行 追加時はattributesがnilになる" do
-      query = TestItem.put.item(id: "foo", name: "John")
-      result = query.execute client
-      expect(result).to eq(nil)
+      res = @client.get_item(table_name: table, key: {id: 'poyo'})
+      expect(res.item.to_hash).to eq(data.deep_stringify_keys)
     end
 
-    # it "条件ありput_item" do
-    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(name: "== 太郎")
-    #   expect(query.query).to eq({
-    #                                 table_name: "test_put_item",
-    #                                 item: {id: "hoge", name: "次郎"},
-    #                                 :expected => {:name => {:value => "太郎", :comparison_operator => "EQ"}},
-    #                                 return_values: "ALL_OLD",
-    #                             })
-    #
-    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(category_id: "== 1")
-    #   expect(query.query).to eq({
-    #                                 table_name: "test_put_item",
-    #                                 item: {id: "hoge", name: "次郎"},
-    #                                 :expected => {:category_id => {:value => 1, :comparison_operator => "EQ"}},
-    #                                 return_values: "ALL_OLD",
-    #                             })
-    #
-    #   query = TestPutItem.put.item(id: "hoge", name: "次郎").expected(category_id: "between 0 2")
-    #   expect(query.query).to eq({
-    #                                 table_name: "test_put_item",
-    #                                 item: {id: "hoge", name: "次郎"},
-    #                                 :expected => {:category_id => {:attribute_value_list => [0, 2], :comparison_operator => "BETWEEN"}},
-    #                                 return_values: "ALL_OLD",
-    #                             })
-    # end
-
-    it "条件ありput_item実行 成功すると古いデータを返す" do
-      query = TestItem.put.item(id: "hoge", name: "次郎").expected(name: "== 太郎")
-      result = query.execute client
-      expect(result.attributes).to eq({id: "hoge", name: "太郎"})
-      expect(result.metadata).to eq(consumed_capacity: nil, item_collection_metrics: nil)
+    it 'failed expect' do
+      data={id: 'poyo', param1: 104+1, param2: 204, param3: "poyo", param4: [1, 0, 4]<<'x'}
+      builder.name(table).item(data).return_values(:ALL_OLD).expected(param1: 0)
+      expect { @client.put_item(builder.build) }.to raise_error(Aws::DynamoDB::Errors::ConditionalCheckFailedException)
     end
 
-    describe "条件指定" do
-      it "undefined operator" do
-        expect { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "= 1") }.to raise_error(ArgumentError)
-      end
-
-      describe :== do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "== 1") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:value => 1, :comparison_operator => "EQ"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-          expect(result.metadata).to eq(consumed_capacity: nil, item_collection_metrics: nil)
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "== 2")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
-
-      describe :!= do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "!= 0") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:value => 0, :comparison_operator => "NE"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "== 2")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
+    it :expected do
+      data={id: 'poyo', param1: 104+1, param2: 204, param3: "poyo", param4: [1, 0, 4]<<'x'}
+      builder.name(table).item(data).return_values(:ALL_OLD).expected(param1: 104, param4: [1, 0, 4])
+      result = @client.put_item(builder.build)
+      expect(result.error).to eq(nil)
+      expect(result.attributes["param1"]).to eq(104)
 
-      describe :> do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "> 0") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:value => 0, :comparison_operator => "GT"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "> 2")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
 
-      describe :>= do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: ">= 1") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:value => 1, :comparison_operator => "GE"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "> 2")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
-
-      describe :< do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "< 2") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:value => 2, :comparison_operator => "LT"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "< 0")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
-
-      describe :<= do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "<= 1") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:value => 1, :comparison_operator => "LE"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "<= 0")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
-
-      describe :between do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "between 1 2") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:category_id => {:attribute_value_list => [1, 2], :comparison_operator => "BETWEEN"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(category_id: "between 2 3")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
-
-      describe :contain do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "contains uga") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:id => {:value => "uga", :comparison_operator => "CONTAINS"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "contains ppp")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
+      res = @client.get_item(table_name: table, key: {id: 'poyo'})
+      expect(res.item["param1"]).to eq(105)
+    end
 
-      describe :not_contain do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "not_contains ppp") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:id => {:value => "ppp", :comparison_operator => "NOT_CONTAINS"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "not_contains uga")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
+    it :between do
+      data={id: 'poyo', param1: 105+1, param2: 204, param3: "poyo", param4: [1, 0, 4, 'x']}
+      builder.name(table).item(data).return_values(:ALL_OLD).expected([[:param1, :BETWEEN, [104, 106]]])
 
-      describe :begins_with do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "begins_with fug") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:id => {:value => "fug", :comparison_operator => "BEGINS_WITH"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "begins_with uga")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
+      result = @client.put_item(builder.build)
+      expect(result.error).to eq(nil)
+      expect(result.attributes["param1"]).to eq(105)
+    end
 
-      describe :is_null do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(bar: "is_null") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:bar => {:comparison_operator => "NULL"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(id: "is_null")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
+    it :in do
+      data={id: 'poyo', param1: 106+1, param2: 204, param3: "poyo", param4: [1, 0, 4, 'x']}
+      builder.name(table).item(data).return_values(:ALL_OLD).add_expected(:param1, :IN, [101, 103, 106])
 
-      describe :is_not_null do
-        let(:query) { TestItem.put.item(id: "fuga", category_id: 1).expected(id: "is_not_null") }
-        it :query do
-          expect(query.query).to eq(table_name: "test_put_item",
-                                    item: {id: "fuga", category_id: 1},
-                                    expected: {:id => {:comparison_operator => "NOT_NULL"}},
-                                    return_values: "ALL_OLD")
-        end
-        it :execute do
-          result = query.execute client
-          expect(result.attributes).to eq({id: "fuga", category_id: 1})
-        end
-        it :error do
-          query = TestItem.put.item(id: "fuga", category_id: 1).expected(bar: "is_not_null")
-          expect(query.execute(client)).to eq(false)
-        end
-      end
+      result = @client.put_item(builder.build)
+      expect(result.error).to eq(nil)
+      expect(result.attributes["param1"]).to eq(106)
     end
-    #
-    # it :< do
-    #   query = TestPutItem.put.item(id: "fuga", category_id: 1).expected(category_id: "< 2")
-    #   result = query.execute client
-    #   expect(result.attributes).to eq({id: "fuga", category_id: 1})
-    # end
-    # it :between do
-    #   query = TestPutItem.put.item(id: "fuga", category_id: 1).expected(category_id: "between 1 2")
-    #   result = query.execute client
-    #   expect(result.attributes).to eq({id: "fuga", category_id: 1})
-    # end
   end
 end
 

data/spec/lib/dymos/query/query_spec.rb

@@ -1,107 +1,57 @@
 describe Dymos::Query::Query do
-  before :all do
-    Aws.config[:region] = 'us-west-1'
-    Aws.config[:endpoint] = 'http://localhost:4567'
-    Aws.config[:access_key_id] = 'XXX'
-    Aws.config[:secret_access_key] = 'XXX'
 
-    client = Aws::DynamoDB::Client.new
-    client.delete_table(table_name: 'test_query_item') if client.list_tables[:table_names].include?('test_query_item')
-    client.create_table(
-        table_name: 'test_query_item',
-        attribute_definitions: [
-            {attribute_name: 'id', attribute_type: 'S'},
-            {attribute_name: 'category_id', attribute_type: 'N'},
-            {attribute_name: 'other_id', attribute_type: 'N'},
-        ],
-        key_schema: [
-            {attribute_name: 'id', key_type: 'HASH'},
-            {attribute_name: 'category_id', key_type: 'RANGE'}
-        ],
-        global_secondary_indexes: [
-            {
-                index_name: "index_other_id",
-                key_schema: [
-                    {attribute_name: "id", key_type: "HASH"},
-                    {attribute_name: "other_id", key_type: "RANGE"},
-                ],
-                projection: {
-                    projection_type: "ALL",
-                },
-                provisioned_throughput: {
-                    read_capacity_units: 1,
-                    write_capacity_units: 1,
-                },
-            },
-        ],
-        provisioned_throughput: {
-            read_capacity_units: 1,
-            write_capacity_units: 1,
-        })
-    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 0, other_id: 1})
-    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 1, other_id: 2})
-    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 2, other_id: 3})
-    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 3, other_id: 4})
-    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 4, other_id: 5})
-    client.put_item(table_name: 'test_query_item', item: {id: 'hoge', category_id: 5, other_id: 6})
+  let(:builder) { Dymos::Query::Query.new }
+  let(:result_count) { @client.query(builder.build)[:count] }
 
-    class TestItem < Dymos::Model
-      table :test_query_item
-      field :id, :string
-      field :other_id, :integer
-    end
+  it 'HASH search' do
+    builder.name('ProductCatalog').where(Id: 101)
+    expect(@client.query(builder.build)[:count]).to eq(1)
+    builder.name('ProductCatalog').conditions([[:Id, 101]])
+    expect(@client.query(builder.build)[:count]).to eq(1)
   end
 
-  let(:client) { Aws::DynamoDB::Client.new }
-  describe :put_item do
-    it "ハッシュ+レンジ検索" do
-      items = TestItem.query.key_conditions(
-          id: "== hoge",
-          category_id:"== 0"
-      ).execute
-      expect(items.first.id).to eq('hoge')
-      expect(items.first.other_id).to eq(1)
-    end
+  it 'HASH RANGE search' do
+    builder.name('Thread').where(ForumName: 'DynamoDB', Subject: 'DynamoDB Thread 1')
+    expect(@client.query(builder.build)[:count]).to eq(1)
+    builder.name('Thread').where([:ForumName, :eq, 'DynamoDB'], [:Subject, :eq, 'DynamoDB Thread 1'])
+    expect(@client.query(builder.build)[:count]).to eq(1)
+    builder.name('Thread').conditions([[:ForumName, 'DynamoDB'], [:Subject, 'DynamoDB Thread 1']])
+    expect(@client.query(builder.build)[:count]).to eq(1)
+    builder.name('Thread').add_conditions(:ForumName, 'DynamoDB').add_conditions(:Subject, :eq, 'DynamoDB Thread 1')
+    expect(@client.query(builder.build)[:count]).to eq(1)
+  end
 
-    it "ハッシュのみ検索" do
-      items = TestItem.query.key_conditions(
-          id: "== hoge"
-      ).execute
-      expect(items.length).to eq(6)
-    end
-    describe "クエリ生成" do
-      describe "グローバルセカンダリインデックスを利用した検索" do
-        let(:query) {
-          TestItem.query.index_name(:index_other_id).key_conditions(
-              id: "== hoge",
-              other_id: "between 1 3"
-          )
-        }
-        it :query do
-          expect(query.query).to eq(
-                                     table_name: 'test_query_item',
-                                     index_name: 'index_other_id',
-                                     key_conditions: {
-                                         id: {
-                                             attribute_value_list: ["hoge"],
-                                             comparison_operator: "EQ"
-                                         },
-                                         other_id: {
-                                             attribute_value_list: [1, 3],
-                                             comparison_operator: "BETWEEN"
-                                         }},
-                                     consistent_read: false,
-                                 )
-        end
-        it :execute do
-          res = query.execute client
-          expect(res.size).to eq(3)
-          expect(res.first.metadata).to eq(count: 3, scanned_count: 3, last_evaluated_key: nil, consumed_capacity: nil)
-        end
+  it 'only HASH search' do
+    builder.name('Reply').where(Id: 'DynamoDB#DynamoDB Thread 1')
+    result = @client.query(builder.build)
+    expect(result[:count]).to eq(3)
+  end
 
+  it :exclusive_start_key do
+    builder.name('Reply').where(Id: 'DynamoDB#DynamoDB Thread 1').start_key(Id: 'DynamoDB#DynamoDB Thread 1', ReplyDateTime: "2011-12-11T00:40:57.165Z")
+    result = @client.query(builder.build)
+    expect(result[:count]).to eq(2)
+  end
 
-      end
+  describe :order do
+    it :asc do
+      builder.name('Reply').where(Id: 'DynamoDB#DynamoDB Thread 1').limit(1).asc
+      result = @client.query(builder.build)
+      expect(result[:items].first["ReplyDateTime"]).to eq("2011-12-11T00:40:57.165Z")
+    end
+    it :desc do
+      builder.name('Reply').where(Id: 'DynamoDB#DynamoDB Thread 1').limit(1).desc
+      result = @client.query(builder.build)
+      expect(result[:items].first["ReplyDateTime"]).to eq("2011-12-25T00:40:57.165Z")
     end
   end
+
+  it 'HASH RANGE with filter' do
+    builder.name('Thread').where(ForumName: 'DynamoDB')
+    expect(@client.query(builder.build)[:count]).to eq(2)
+
+    builder.name('Thread').where(ForumName: 'DynamoDB').filter([[:Message, "DynamoDB thread 2 message text"]])
+    expect(@client.query(builder.build)[:count]).to eq(1)
+  end
 end
 

data/spec/lib/dymos/query/scan_spec.rb

@@ -1,55 +1,61 @@
 describe Dymos::Query::Scan do
-  before :all do
-    Aws.config[:region] = 'us-west-1'
-    Aws.config[:endpoint] = 'http://localhost:4567'
-    Aws.config[:access_key_id] = 'XXX'
-    Aws.config[:secret_access_key] = 'XXX'
-
-    client = Aws::DynamoDB::Client.new
-    client.delete_table(table_name: 'test_get_item') if client.list_tables[:table_names].include?('test_get_item')
-    client.create_table(
-        table_name: 'test_get_item',
-        attribute_definitions: [
-            {attribute_name: 'id', attribute_type: 'S'},
-            {attribute_name: 'category_id', attribute_type: 'N'},
-        ],
-        key_schema: [
-            {attribute_name: 'id', key_type: 'HASH'},
-            {attribute_name: 'category_id', key_type: 'RANGE'}
-        ],
-        provisioned_throughput: {
-            read_capacity_units: 1,
-            write_capacity_units: 1,
-        })
-    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 0, name: '太郎'})
-    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 1})
-    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 2})
-    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 3})
-    client.put_item(table_name: 'test_get_item', item: {id: 'hoge', category_id: 4})
-
-    class TestItem < Dymos::Model
-      table :test_get_item
-      field :id, :string
-    end
-  end
 
-  let(:client) { Aws::DynamoDB::Client.new }
-  describe :scan do
+  describe 'build query' do
+    let(:builder) { Dymos::Query::Scan.new }
 
-    it :query do
-      expect(TestItem.scan.limit(100).query).to eq(table_name: "test_get_item", limit: 100)
+    it :name do
+      builder.name('hoge')
+      expect(builder.build).to eq({table_name: 'hoge'})
+      # .attributes('item1', 'item2').limit(20).select('ALL_ATTRIBUTES')
+      # .filter([[:item1, :eq, 1], [:item2, :begins_with, 'fuga']], :or)
+    end
+    it :name do
+      builder.attributes('item1', 'item2')
+      expect(builder.build).to eq({attributes_to_get: ['item1', 'item2']})
     end
 
-    it :execute do
-      res=TestItem.scan.execute
-      expect(res.size).to eq(5)
-      expect(res.first.metadata).to eq(count: 5, scanned_count: 5, last_evaluated_key: nil, consumed_capacity: nil)
+    it :filter do
+      builder.filter([[:item1, :eq, [1, 2, 3]], [:item2, :begins_with, 'fuga']], :or)
+      expect(builder.build).to eq({scan_filter: {
+                                    'item1' => {
+                                      attribute_value_list: [1, 2, 3],
+                                      comparison_operator: 'EQ'
+                                    },
+                                    'item2' => {
+                                      attribute_value_list: ['fuga'],
+                                      comparison_operator: 'BEGINS_WITH'
+                                    }},
+                                   conditional_operator: 'OR'
+                                  })
     end
 
+    it :add_filter, :filter_operator do
+      builder.add_filter(:item1, [1, 2, 3]).add_filter(:item2, :begins_with, 'fuga').filter_operator(:or)
+      expect(builder.build).to eq({scan_filter: {
+                                    'item1' => {
+                                      attribute_value_list: [1, 2, 3],
+                                      comparison_operator: 'EQ'
+                                    },
+                                    'item2' => {
+                                      attribute_value_list: ['fuga'],
+                                      comparison_operator: 'BEGINS_WITH'
+                                    }},
+                                   conditional_operator: 'OR'
+                                  })
+    end
 
-    it :query do
-      expect(TestItem.scan.limit(100).exclusive_start_key('hoge').query).to eq(table_name: "test_get_item", exclusive_start_key:"hoge", limit: 100)
+    it :start_key do
+      builder.start_key(id: 1, hoge: 'fuga')
+      expect(builder.build).to eq({exclusive_start_key: {"id" => 1, "hoge" => "fuga"}})
     end
+
+    it '絞込' do
+      builder.name(:ProductCatalog).add_filter(:Authors, :contains, "Author 1")
+      result = @client.scan(builder.build)
+      expect(result[:scanned_count]).to eq(8)
+      expect(result[:count]).to eq(3)
+    end
+
   end
 end