dynamoid 0.6.0 → 0.6.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -5,11 +5,11 @@
5
5
 
6
6
  Gem::Specification.new do |s|
7
7
  s.name = "dynamoid"
8
- s.version = "0.6.0"
8
+ s.version = "0.6.1"
9
9
 
10
10
  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
11
11
  s.authors = ["Josh Symonds"]
12
- s.date = "2012-12-19"
12
+ s.date = "2013-01-09"
13
13
  s.description = "Dynamoid is an ORM for Amazon's DynamoDB that supports offline development, associations, querying, and everything else you'd expect from an ActiveRecord-style replacement."
14
14
  s.email = "josh@joshsymonds.com"
15
15
  s.extra_rdoc_files = [
@@ -139,7 +139,7 @@ Gem::Specification.new do |s|
139
139
  s.homepage = "http://github.com/Veraticus/Dynamoid"
140
140
  s.licenses = ["MIT"]
141
141
  s.require_paths = ["lib"]
142
- s.rubygems_version = "1.8.24"
142
+ s.rubygems_version = "1.8.23"
143
143
  s.summary = "Dynamoid is an ORM for Amazon's DynamoDB"
144
144
 
145
145
  if s.respond_to? :specification_version then
data/VERSION CHANGED
@@ -1 +1 @@
1
- 0.6.0
1
+ 0.6.1
@@ -69,7 +69,7 @@ module Dynamoid
69
69
  self.attributes.each do |attribute, options|
70
70
  hash[attribute] = undump_field(incoming[attribute], options)
71
71
  end
72
- incoming.each {|attribute, value| hash[attribute] ||= value }
72
+ incoming.each {|attribute, value| hash[attribute] = value unless hash.has_key? attribute }
73
73
  end
74
74
  end
75
75
 
@@ -118,6 +118,8 @@ module Dynamoid
118
118
  else
119
119
  raise ArgumentError, "Boolean column neither true nor false"
120
120
  end
121
+ else
122
+ raise ArgumentError, "Unknown type #{options[:type]}"
121
123
  end
122
124
  end
123
125
 
@@ -2,382 +2,366 @@ require 'dynamoid/adapter/aws_sdk'
2
2
  require File.expand_path(File.dirname(__FILE__) + '../../../spec_helper')
3
3
 
4
4
  describe Dynamoid::Adapter::AwsSdk do
5
+ before(:each) do
6
+ pending "You must have an active DynamoDB connection" unless ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
7
+ end
5
8
 
6
- if ENV['ACCESS_KEY'] && ENV['SECRET_KEY']
9
+ #
10
+ # These let() definitions create tables "dynamoid_tests_TestTable<N>" and return the
11
+ # name of the table. An after(:each) handler drops any tables created this way after each test
12
+ #
13
+ # Name => Constructor args
14
+ {
15
+ 1 => [:id],
16
+ 2 => [:id],
17
+ 3 => [:id, {:range_key => {:range => :number}}],
18
+ 4 => [:id, {:range_key => {:range => :number}}]
19
+ }.each do |n, args|
20
+ name = "dynamoid_tests_TestTable#{n}"
21
+ let(:"test_table#{n}") do
22
+ Dynamoid::Adapter.create_table(name, *args)
23
+ @created_tables << name
24
+ name
25
+ end
26
+ end
27
+
28
+ before(:each) { @created_tables = [] }
29
+ after(:each) do
30
+ @created_tables.each do |t|
31
+ Dynamoid::Adapter.delete_table(t)
32
+ end
33
+ end
34
+
35
+ #
36
+ # Returns a random key parition if partitioning is on, or an empty string if
37
+ # it is off, useful for shared examples where partitioning may or may not be on
38
+ #
39
+ def key_partition
40
+ Dynamoid::Config.partitioning? ? ".#{Random.rand(Dynamoid::Config.partition_size)}" : ''
41
+ end
42
+
43
+ #
44
+ # Tests adapter against ranged tables
45
+ #
46
+ shared_examples 'range queries' do
47
+ before do
48
+ Dynamoid::Adapter.put_item(test_table3, {:id => "1#{key_partition}", :range => 1.0})
49
+ Dynamoid::Adapter.put_item(test_table3, {:id => "1#{key_partition}", :range => 3.0})
50
+ end
7
51
 
8
- context 'without a preexisting table' do
9
- # CreateTable and DeleteTable
10
- it 'performs CreateTable and DeleteTable' do
11
- table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key => { :created_at => :number })
52
+ it 'performs query on a table with a range and selects items in a range' do
53
+ Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
54
+ end
12
55
 
13
- Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
56
+ it 'performs query on a table with a range and selects items greater than' do
57
+ Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
58
+ end
14
59
 
15
- Dynamoid::Adapter.delete_table('CreateTable')
16
- end
60
+ it 'performs query on a table with a range and selects items less than' do
61
+ Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
17
62
  end
18
63
 
19
- context 'with a preexisting table without paritioning' do
20
- before(:all) do
21
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
22
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
23
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
24
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable4', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable4')
25
- end
64
+ it 'performs query on a table with a range and selects items gte' do
65
+ Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
66
+ end
26
67
 
27
- # GetItem, PutItem and DeleteItem
28
- it "performs GetItem for an item that does not exist" do
29
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
30
- end
68
+ it 'performs query on a table with a range and selects items lte' do
69
+ Dynamoid::Adapter.query(test_table3, :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
70
+ end
71
+ end
72
+
73
+ #
74
+ # Tests scan_index_forwards flag behavior on range queries
75
+ #
76
+ shared_examples 'correct ordering' do
77
+ before(:each) do
78
+ pending "Order is not preserved on paritioned tables" if(Dynamoid::Config.partitioning?)
79
+ Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 1, :range => 1.0})
80
+ Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 2, :range => 2.0})
81
+ Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 3, :range => 3.0})
82
+ Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 4, :range => 4.0})
83
+ Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 5, :range => 5.0})
84
+ Dynamoid::Adapter.put_item(test_table4, {:id => "1#{key_partition}", :order => 6, :range => 6.0})
85
+ end
31
86
 
32
- it "performs GetItem for an item that does exist" do
33
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
87
+ it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
88
+ query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
89
+ query[0].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
90
+ query[1].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
91
+ query[2].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
92
+ query[3].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
93
+ query[4].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
94
+ query[5].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
95
+ end
96
+
97
+ it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
98
+ query = Dynamoid::Adapter.query(test_table4, :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
99
+ query[5].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
100
+ query[4].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
101
+ query[3].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
102
+ query[2].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
103
+ query[1].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
104
+ query[0].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
105
+ end
106
+ end
107
+
108
+
109
+ context 'without a preexisting table' do
110
+ # CreateTable and DeleteTable
111
+ it 'performs CreateTable and DeleteTable' do
112
+ table = Dynamoid::Adapter.create_table('CreateTable', :id, :range_key => { :created_at => :number })
34
113
 
35
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:name => 'Josh', :id => '1'}
114
+ Dynamoid::Adapter.connection.tables.collect{|t| t.name}.should include 'CreateTable'
36
115
 
37
- Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
116
+ Dynamoid::Adapter.delete_table('CreateTable')
117
+ end
118
+ end
38
119
 
39
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
40
- end
41
120
 
42
- it 'performs GetItem for an item that does exist with a range key' do
43
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 2.0})
121
+ context 'with a preexisting table without paritioning' do
122
+ # GetItem, PutItem and DeleteItem
123
+ it "performs GetItem for an item that does not exist" do
124
+ Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
125
+ end
44
126
 
45
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
127
+ it "performs GetItem for an item that does exist" do
128
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
46
129
 
47
- Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0)
130
+ Dynamoid::Adapter.get_item(test_table1, '1').should == {:name => 'Josh', :id => '1'}
48
131
 
49
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable3', '1', :range_key => 2.0).should be_nil
50
- end
132
+ Dynamoid::Adapter.delete_item(test_table1, '1')
51
133
 
52
- it 'performs DeleteItem for an item that does not exist' do
53
- Dynamoid::Adapter.delete_item('dynamoid_tests_TestTable1', '1')
134
+ Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
135
+ end
54
136
 
55
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should be_nil
56
- end
137
+ it 'performs GetItem for an item that does exist with a range key' do
138
+ Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 2.0})
57
139
 
58
- it 'performs PutItem for an item that does not exist' do
59
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
140
+ Dynamoid::Adapter.get_item(test_table3, '1', :range_key => 2.0).should == {:name => 'Josh', :id => '1', :range => 2.0}
60
141
 
61
- Dynamoid::Adapter.get_item('dynamoid_tests_TestTable1', '1').should == {:id => '1', :name => 'Josh'}
62
- end
142
+ Dynamoid::Adapter.delete_item(test_table3, '1', :range_key => 2.0)
63
143
 
64
- # BatchGetItem
65
- it "performs BatchGetItem with singular keys" do
66
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
67
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable2', {:id => '1', :name => 'Justin'})
144
+ Dynamoid::Adapter.get_item(test_table3, '1', :range_key => 2.0).should be_nil
145
+ end
68
146
 
69
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
70
- results.size.should == 2
71
- results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
72
- results['dynamoid_tests_TestTable2'].should include({:name => 'Justin', :id => '1'})
73
- end
147
+ it 'performs DeleteItem for an item that does not exist' do
148
+ Dynamoid::Adapter.delete_item(test_table1, '1')
74
149
 
75
- it "performs BatchGetItem with multiple keys" do
76
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
77
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
150
+ Dynamoid::Adapter.get_item(test_table1, '1').should be_nil
151
+ end
78
152
 
79
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
80
- results.size.should == 1
81
- results['dynamoid_tests_TestTable1'].should include({:name => 'Josh', :id => '1'})
82
- results['dynamoid_tests_TestTable1'].should include({:name => 'Justin', :id => '2'})
83
- end
153
+ it 'performs PutItem for an item that does not exist' do
154
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
84
155
 
85
- it 'performs BatchGetItem with one ranged key' do
86
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
87
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
156
+ Dynamoid::Adapter.get_item(test_table1, '1').should == {:id => '1', :name => 'Josh'}
157
+ end
88
158
 
89
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
90
- results.size.should == 1
91
- results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
92
- end
159
+ # BatchGetItem
160
+ it "performs BatchGetItem with singular keys" do
161
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
162
+ Dynamoid::Adapter.put_item(test_table2, {:id => '1', :name => 'Justin'})
93
163
 
94
- it 'performs BatchGetItem with multiple ranged keys' do
95
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
96
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
164
+ results = Dynamoid::Adapter.batch_get_item(test_table1 => '1', test_table2 => '1')
165
+ results.size.should == 2
166
+ results[test_table1].should include({:name => 'Josh', :id => '1'})
167
+ results[test_table2].should include({:name => 'Justin', :id => '1'})
168
+ end
169
+
170
+ it "performs BatchGetItem with multiple keys" do
171
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
172
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
173
+
174
+ results = Dynamoid::Adapter.batch_get_item(test_table1 => ['1', '2'])
175
+ results.size.should == 1
176
+ results[test_table1].should include({:name => 'Josh', :id => '1'})
177
+ results[test_table1].should include({:name => 'Justin', :id => '2'})
178
+ end
179
+
180
+ it 'performs BatchGetItem with one ranged key' do
181
+ Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
182
+ Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
183
+
184
+ results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0]])
185
+ results.size.should == 1
186
+ results[test_table3].should include({:name => 'Josh', :id => '1', :range => 1.0})
187
+ end
188
+
189
+ it 'performs BatchGetItem with multiple ranged keys' do
190
+ Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
191
+ Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
192
+
193
+ results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0],['2', 2.0]])
194
+ results.size.should == 1
195
+ results[test_table3].should include({:name => 'Josh', :id => '1', :range => 1.0})
196
+ results[test_table3].should include({:name => 'Justin', :id => '2', :range => 2.0})
197
+ end
198
+
199
+ # BatchDeleteItem
200
+ it "performs BatchDeleteItem with singular keys" do
201
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
202
+ Dynamoid::Adapter.put_item(test_table2, {:id => '1', :name => 'Justin'})
97
203
 
98
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
99
- results.size.should == 1
100
- results['dynamoid_tests_TestTable3'].should include({:name => 'Josh', :id => '1', :range => 1.0})
101
- results['dynamoid_tests_TestTable3'].should include({:name => 'Justin', :id => '2', :range => 2.0})
102
- end
204
+ Dynamoid::Adapter.batch_delete_item(test_table1 => ['1'], test_table2 => ['1'])
103
205
 
104
- # BatchDeleteItem
105
- it "performs BatchDeleteItem with singular keys" do
106
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
107
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable2', {:id => '1', :name => 'Justin'})
108
-
109
- Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable1' => ['1'], 'dynamoid_tests_TestTable2' => ['1'])
110
-
111
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => '1', 'dynamoid_tests_TestTable2' => '1')
112
- results.size.should == 0
113
-
114
- results['dynamoid_tests_TestTable1'].should_not include({:name => 'Josh', :id => '1'})
115
- results['dynamoid_tests_TestTable2'].should_not include({:name => 'Justin', :id => '1'})
116
- end
117
-
118
- it "performs BatchDeleteItem with multiple keys" do
119
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
120
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
121
-
122
- Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable1' => ['1', '2'])
123
-
124
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable1' => ['1', '2'])
125
- results.size.should == 0
126
-
127
- results['dynamoid_tests_TestTable1'].should_not include({:name => 'Josh', :id => '1'})
128
- results['dynamoid_tests_TestTable1'].should_not include({:name => 'Justin', :id => '2'})
129
- end
130
-
131
- it 'performs BatchDeleteItem with one ranged key' do
132
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
133
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
134
-
135
- Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
136
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0]])
137
- results.size.should == 0
138
-
139
- results['dynamoid_tests_TestTable3'].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
140
- end
141
-
142
- it 'performs BatchDeleteItem with multiple ranged keys' do
143
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :name => 'Josh', :range => 1.0})
144
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '2', :name => 'Justin', :range => 2.0})
145
-
146
- Dynamoid::Adapter.batch_delete_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
147
- results = Dynamoid::Adapter.batch_get_item('dynamoid_tests_TestTable3' => [['1', 1.0],['2', 2.0]])
148
- results.size.should == 0
149
-
150
- results['dynamoid_tests_TestTable3'].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
151
- results['dynamoid_tests_TestTable3'].should_not include({:name => 'Justin', :id => '2', :range => 2.0})
152
- end
153
-
154
- # ListTables
155
- it 'performs ListTables' do
156
- Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable1'
157
- Dynamoid::Adapter.list_tables.should include 'dynamoid_tests_TestTable2'
158
- end
159
-
160
- # Query
161
- it 'performs query on a table and returns items' do
162
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
163
-
164
- Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
165
- end
166
-
167
- it 'performs query on a table and returns items if there are multiple items' do
168
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
169
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
170
-
171
- Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
172
- end
173
-
174
- context 'range queries' do
175
- before do
176
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 1.0})
177
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1', :range => 3.0})
178
- end
179
-
180
- it 'performs query on a table with a range and selects items in a range' do
181
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
182
- end
183
-
184
- it 'performs query on a table with a range and selects items greater than' do
185
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
186
- end
187
-
188
- it 'performs query on a table with a range and selects items less than' do
189
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
190
- end
191
-
192
- it 'performs query on a table with a range and selects items gte' do
193
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
194
- end
195
-
196
- it 'performs query on a table with a range and selects items lte' do
197
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
198
- end
199
- end
200
-
201
- # Scan
202
- it 'performs scan on a table and returns items' do
203
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
204
-
205
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
206
- end
207
-
208
- it 'performs scan on a table and returns items if there are multiple items but only one match' do
209
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
210
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Justin'})
211
-
212
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
213
- end
214
-
215
- it 'performs scan on a table and returns multiple items if there are multiple matches' do
216
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
217
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
218
-
219
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
220
- end
221
-
222
- it 'performs scan on a table and returns all items if no criteria are specified' do
223
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1', :name => 'Josh'})
224
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2', :name => 'Josh'})
225
-
226
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
227
- end
206
+ results = Dynamoid::Adapter.batch_get_item(test_table1 => '1', test_table2 => '1')
207
+ results.size.should == 0
228
208
 
229
- context 'correct ordering ' do
230
- before do
231
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 1, :range => 1.0})
232
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 2, :range => 2.0})
233
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 3, :range => 3.0})
234
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 4, :range => 4.0})
235
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 5, :range => 5.0})
236
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1', :order => 6, :range => 6.0})
237
- end
238
-
239
- it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
240
- query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
241
- query[0].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
242
- query[1].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
243
- query[2].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
244
- query[3].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
245
- query[4].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
246
- query[5].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
247
- end
248
-
249
- it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
250
- query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
251
- query[5].should == {:id => '1', :order => 1, :range => BigDecimal.new(1)}
252
- query[4].should == {:id => '1', :order => 2, :range => BigDecimal.new(2)}
253
- query[3].should == {:id => '1', :order => 3, :range => BigDecimal.new(3)}
254
- query[2].should == {:id => '1', :order => 4, :range => BigDecimal.new(4)}
255
- query[1].should == {:id => '1', :order => 5, :range => BigDecimal.new(5)}
256
- query[0].should == {:id => '1', :order => 6, :range => BigDecimal.new(6)}
257
- end
258
- end
209
+ results[test_table1].should_not include({:name => 'Josh', :id => '1'})
210
+ results[test_table2].should_not include({:name => 'Justin', :id => '1'})
259
211
  end
260
-
261
- context 'with a preexisting table with paritioning' do
262
- before(:all) do
263
- @previous_value = Dynamoid::Config.partitioning
264
- Dynamoid::Config.partitioning = true
265
-
266
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable1', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable1')
267
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable2', :id) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable2')
268
- Dynamoid::Adapter.create_table('dynamoid_tests_TestTable3', :id, :range_key => { :range => :number }) unless Dynamoid::Adapter.list_tables.include?('dynamoid_tests_TestTable3')
269
- end
270
-
271
- after(:all) do
272
- Dynamoid::Config.partitioning = @previous_value
273
- end
274
-
275
- # Query
276
- it 'performs query on a table and returns items' do
277
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
278
-
279
- Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
280
- end
281
-
282
- it 'performs query on a table and returns items if there are multiple items' do
283
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
284
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Justin'})
285
-
286
- Dynamoid::Adapter.query('dynamoid_tests_TestTable1', :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
287
- end
288
-
289
- context 'range queries' do
290
- before do
291
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1.1', :range => 1.0})
292
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable3', {:id => '1.1', :range => 3.0})
293
- end
294
-
295
- it 'performs query on a table with a range and selects items in a range' do
296
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_value => 0.0..3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
297
- end
298
-
299
- it 'performs query on a table with a range and selects items greater than' do
300
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_greater_than => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(3)}]
301
- end
302
-
303
- it 'performs query on a table with a range and selects items less than' do
304
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_less_than => 2.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}]
305
- end
306
-
307
- it 'performs query on a table with a range and selects items gte' do
308
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_gte => 1.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
309
- end
310
-
311
- it 'performs query on a table with a range and selects items lte' do
312
- Dynamoid::Adapter.query('dynamoid_tests_TestTable3', :hash_value => '1', :range_lte => 3.0).should =~ [{:id => '1', :range => BigDecimal.new(1)}, {:id => '1', :range => BigDecimal.new(3)}]
313
- end
314
- end
315
-
316
- # Scan
317
- it 'performs scan on a table and returns items' do
318
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
319
-
320
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
321
- end
322
-
323
- it 'performs scan on a table and returns items if there are multiple items but only one match' do
324
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
325
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Justin'})
326
-
327
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
328
- end
329
-
330
- it 'performs scan on a table and returns multiple items if there are multiple matches' do
331
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
332
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Josh'})
333
-
334
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
335
- end
336
-
337
- it 'performs scan on a table and returns all items if no criteria are specified' do
338
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '1.1', :name => 'Josh'})
339
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable1', {:id => '2.1', :name => 'Josh'})
340
-
341
- Dynamoid::Adapter.scan('dynamoid_tests_TestTable1', {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
342
- end
212
+
213
+ it "performs BatchDeleteItem with multiple keys" do
214
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
215
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
216
+
217
+ Dynamoid::Adapter.batch_delete_item(test_table1 => ['1', '2'])
218
+
219
+ results = Dynamoid::Adapter.batch_get_item(test_table1 => ['1', '2'])
220
+ results.size.should == 0
343
221
 
344
- context 'correct ordering ' do
345
- before do
346
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.1', :range => 1.0})
347
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.2', :range => 2.0})
348
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.3', :range => 3.0})
349
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.4', :range => 4.0})
350
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.5', :range => 5.0})
351
- Dynamoid::Adapter.put_item('dynamoid_tests_TestTable4', {:id => '1.6', :range => 6.0})
352
- end
353
-
354
- it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward true' do
355
- query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => true)
356
- query[0].should == {:id => '1', :range => BigDecimal.new(1)}
357
- query[1].should == {:id => '1', :range => BigDecimal.new(2)}
358
- query[2].should == {:id => '1', :range => BigDecimal.new(3)}
359
- query[3].should == {:id => '1', :range => BigDecimal.new(4)}
360
- query[4].should == {:id => '1', :range => BigDecimal.new(5)}
361
- query[5].should == {:id => '1', :range => BigDecimal.new(6)}
362
- end
363
-
364
- it 'performs query on a table with a range and selects items less than that is in the correct order, scan_index_forward false' do
365
- query = Dynamoid::Adapter.query('dynamoid_tests_TestTable4', :hash_value => '1', :range_greater_than => 0, :scan_index_forward => false)
366
- query[5].should == {:id => '1', :range => BigDecimal.new(1)}
367
- query[4].should == {:id => '1', :range => BigDecimal.new(2)}
368
- query[3].should == {:id => '1', :range => BigDecimal.new(3)}
369
- query[2].should == {:id => '1', :range => BigDecimal.new(4)}
370
- query[1].should == {:id => '1', :range => BigDecimal.new(5)}
371
- query[0].should == {:id => '1', :range => BigDecimal.new(6)}
372
- end
373
- end
374
- end
375
-
376
- # DescribeTable
377
-
378
- # UpdateItem
379
-
380
- # UpdateTable
222
+ results[test_table1].should_not include({:name => 'Josh', :id => '1'})
223
+ results[test_table1].should_not include({:name => 'Justin', :id => '2'})
224
+ end
225
+
226
+ it 'performs BatchDeleteItem with one ranged key' do
227
+ Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
228
+ Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
229
+
230
+ Dynamoid::Adapter.batch_delete_item(test_table3 => [['1', 1.0]])
231
+ results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0]])
232
+ results.size.should == 0
233
+
234
+ results[test_table3].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
235
+ end
236
+
237
+ it 'performs BatchDeleteItem with multiple ranged keys' do
238
+ Dynamoid::Adapter.put_item(test_table3, {:id => '1', :name => 'Josh', :range => 1.0})
239
+ Dynamoid::Adapter.put_item(test_table3, {:id => '2', :name => 'Justin', :range => 2.0})
240
+
241
+ Dynamoid::Adapter.batch_delete_item(test_table3 => [['1', 1.0],['2', 2.0]])
242
+ results = Dynamoid::Adapter.batch_get_item(test_table3 => [['1', 1.0],['2', 2.0]])
243
+ results.size.should == 0
244
+
245
+ results[test_table3].should_not include({:name => 'Josh', :id => '1', :range => 1.0})
246
+ results[test_table3].should_not include({:name => 'Justin', :id => '2', :range => 2.0})
247
+ end
248
+
249
+ # ListTables
250
+ it 'performs ListTables' do
251
+ #Force creation of the tables
252
+ test_table1; test_table2; test_table3; test_table4
381
253
 
254
+ Dynamoid::Adapter.list_tables.should include test_table1
255
+ Dynamoid::Adapter.list_tables.should include test_table2
256
+ end
257
+
258
+ # Query
259
+ it 'performs query on a table and returns items' do
260
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
261
+
262
+ Dynamoid::Adapter.query(test_table1, :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
263
+ end
264
+
265
+ it 'performs query on a table and returns items if there are multiple items' do
266
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
267
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
268
+
269
+ Dynamoid::Adapter.query(test_table1, :hash_value => '1').should == { :id=> '1', :name=>"Josh" }
270
+ end
271
+
272
+ it_behaves_like 'range queries'
273
+
274
+ # Scan
275
+ it 'performs scan on a table and returns items' do
276
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
277
+
278
+ Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
279
+ end
280
+
281
+ it 'performs scan on a table and returns items if there are multiple items but only one match' do
282
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
283
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Justin'})
284
+
285
+ Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
286
+ end
287
+
288
+ it 'performs scan on a table and returns multiple items if there are multiple matches' do
289
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
290
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Josh'})
291
+
292
+ Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
293
+ end
294
+
295
+ it 'performs scan on a table and returns all items if no criteria are specified' do
296
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1', :name => 'Josh'})
297
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2', :name => 'Josh'})
298
+
299
+ Dynamoid::Adapter.scan(test_table1, {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
300
+ end
301
+
302
+ it_behaves_like 'correct ordering'
303
+ end
304
+
305
+ context 'with a preexisting table with paritioning' do
306
+ before(:all) do
307
+ @previous_value = Dynamoid::Config.partitioning
308
+ Dynamoid::Config.partitioning = true
309
+ end
310
+
311
+ after(:all) do
312
+ Dynamoid::Config.partitioning = @previous_value
313
+ end
314
+
315
+ # Query
316
+ it 'performs query on a table and returns items' do
317
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
318
+
319
+ Dynamoid::Adapter.query(test_table1, :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
320
+ end
321
+
322
+ it 'performs query on a table and returns items if there are multiple items' do
323
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
324
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Justin'})
325
+
326
+ Dynamoid::Adapter.query(test_table1, :hash_value => '1').first.should == { :id=> '1', :name=>"Josh" }
327
+ end
328
+
329
+ it_behaves_like 'range queries'
330
+
331
+ # Scan
332
+ it 'performs scan on a table and returns items' do
333
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
334
+
335
+ Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
336
+ end
337
+
338
+ it 'performs scan on a table and returns items if there are multiple items but only one match' do
339
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
340
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Justin'})
341
+
342
+ Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should == [{ :id=> '1', :name=>"Josh" }]
343
+ end
344
+
345
+ it 'performs scan on a table and returns multiple items if there are multiple matches' do
346
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
347
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Josh'})
348
+
349
+ Dynamoid::Adapter.scan(test_table1, :name => 'Josh').should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
350
+ end
351
+
352
+ it 'performs scan on a table and returns all items if no criteria are specified' do
353
+ Dynamoid::Adapter.put_item(test_table1, {:id => '1.1', :name => 'Josh'})
354
+ Dynamoid::Adapter.put_item(test_table1, {:id => '2.1', :name => 'Josh'})
355
+
356
+ Dynamoid::Adapter.scan(test_table1, {}).should include({:name=>"Josh", :id=>"2"}, {:name=>"Josh", :id=>"1"})
357
+ end
358
+
359
+ it_behaves_like 'correct ordering'
382
360
  end
361
+
362
+ # DescribeTable
363
+
364
+ # UpdateItem
365
+
366
+ # UpdateTable
383
367
  end
@@ -90,9 +90,11 @@ describe "Dynamoid::Persistence" do
90
90
  Address.undump(@address.send(:dump))[:options].should == hash
91
91
  end
92
92
 
93
- it 'dumps a boolean field' do
94
- @address.deliverable = true
95
- Address.undump(@address.send(:dump))[:deliverable].should == true
93
+ [true, false].each do |bool|
94
+ it "dumps a #{bool} boolean field" do
95
+ @address.deliverable = bool
96
+ Address.undump(@address.send(:dump))[:deliverable].should == bool
97
+ end
96
98
  end
97
99
 
98
100
  it 'raises on an invalid boolean value' do
@@ -158,21 +160,33 @@ describe "Dynamoid::Persistence" do
158
160
  end
159
161
  end
160
162
 
161
- it 'raises when dumping a column with an unknown field type' do
162
- clazz = Class.new do
163
- include Dynamoid::Document
164
- table :name => :addresses
163
+ context 'unknown fields' do
164
+ let(:clazz) do
165
+ Class.new do
166
+ include Dynamoid::Document
167
+ table :name => :addresses
165
168
 
166
- field :city
167
- field :options, :serialized
168
- field :deliverable, :bad_type_specifier
169
+ field :city
170
+ field :options, :serialized
171
+ field :deliverable, :bad_type_specifier
172
+ end
169
173
  end
170
-
171
- expect do
172
- clazz.new(:deliverable => true).dump
173
- end.to raise_error(ArgumentError)
174
- end
175
174
 
175
+ it 'raises when undumping a column with an unknown field type' do
176
+ expect do
177
+ clazz.new(:deliverable => true) #undump is called here
178
+ end.to raise_error(ArgumentError)
179
+ end
180
+
181
+ it 'raises when dumping a column with an unknown field type' do
182
+ doc = clazz.new
183
+ doc.deliverable = true
184
+ expect do
185
+ doc.dump
186
+ end.to raise_error(ArgumentError)
187
+ end
188
+ end
189
+
176
190
  context 'update' do
177
191
 
178
192
  before :each do
@@ -7,17 +7,21 @@ require 'rspec'
7
7
  require 'dynamoid'
8
8
  require 'pry'
9
9
  require 'mocha'
10
+ require 'aws-sdk'
10
11
 
11
12
  ENV['ACCESS_KEY'] ||= 'abcd'
12
13
  ENV['SECRET_KEY'] ||= '1234'
13
14
 
15
+ AWS.config({
16
+ :access_key_id => ENV['ACCESS_KEY'],
17
+ :secret_access_key => ENV['SECRET_KEY'],
18
+ :dynamo_db_endpoint => 'localhost',
19
+ :dynamo_db_port => '4567',
20
+ :use_ssl => false
21
+ })
22
+
14
23
  Dynamoid.configure do |config|
15
24
  config.adapter = 'aws_sdk'
16
- config.access_key = ENV['ACCESS_KEY']
17
- config.secret_key = ENV['SECRET_KEY']
18
- config.endpoint = 'localhost'
19
- config.port = '4567'
20
- config.use_ssl = false
21
25
  config.namespace = 'dynamoid_tests'
22
26
  config.warn_on_scan = false
23
27
  end
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: dynamoid
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.6.0
4
+ version: 0.6.1
5
5
  prerelease:
6
6
  platform: ruby
7
7
  authors:
@@ -9,7 +9,7 @@ authors:
9
9
  autorequire:
10
10
  bindir: bin
11
11
  cert_chain: []
12
- date: 2012-12-19 00:00:00.000000000 Z
12
+ date: 2013-01-09 00:00:00.000000000 Z
13
13
  dependencies:
14
14
  - !ruby/object:Gem::Dependency
15
15
  name: activemodel
@@ -362,7 +362,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
362
362
  version: '0'
363
363
  segments:
364
364
  - 0
365
- hash: 1769474617671935621
365
+ hash: 4089934294152976145
366
366
  required_rubygems_version: !ruby/object:Gem::Requirement
367
367
  none: false
368
368
  requirements:
@@ -371,7 +371,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
371
371
  version: '0'
372
372
  requirements: []
373
373
  rubyforge_project:
374
- rubygems_version: 1.8.24
374
+ rubygems_version: 1.8.23
375
375
  signing_key:
376
376
  specification_version: 3
377
377
  summary: Dynamoid is an ORM for Amazon's DynamoDB