1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
|
# to test your new orm_adapter, make an example app that matches the functionality
# found in the existing specs for example, look at spec/orm_adapter/adapters/active_record_spec.rb
#
# Then you can execute this shared spec as follows:
#
# it_should_behave_like "execute app with orm_adapter" do
# let(:user_class) { User }
# let(:note_class) { Note }
#
# # optionaly define the following functions if the ORM does not support
# # this syntax - this should NOT use the orm_adapter, because we're testing that
# def create_model(klass, attrs = {})
# klass.create!(attrs)
# end
#
# def reload_model(model)
# model.class.find(model.id)
# end
# end
#
shared_examples_for "example app with orm_adapter" do
def create_model(klass, attrs = {})
klass.create!(attrs)
end
def reload_model(model)
model.class.find(model.id)
end
describe "an ORM class" do
subject { note_class }
it "#to_adapter should return an adapter instance" do
subject.to_adapter.should be_a(OrmAdapter::Base)
end
it "#to_adapter should return an adapter for the receiver" do
subject.to_adapter.klass.should == subject
end
it "#to_adapter should be cached" do
subject.to_adapter.object_id.should == subject.to_adapter.object_id
end
end
describe "adapter instance" do
let(:note_adapter) { note_class.to_adapter }
let(:user_adapter) { user_class.to_adapter }
describe "#get!(id)" do
it "should return the instance with id if it exists" do
user = create_model(user_class)
user_adapter.get!(user.id).should == user
end
it "should allow to_key like arguments" do
user = create_model(user_class)
user_adapter.get!(user.to_key).should == user
end
it "should raise an error if there is no instance with that id" do
lambda { user_adapter.get!("nonexistent id") }.should raise_error
end
end
describe "#get(id)" do
it "should return the instance with id if it exists" do
user = create_model(user_class)
user_adapter.get(user.id).should == user
end
it "should allow to_key like arguments" do
user = create_model(user_class)
user_adapter.get(user.to_key).should == user
end
it "should return nil if there is no instance with that id" do
user_adapter.get("nonexistent id").should be_nil
end
end
describe "#find_first" do
describe "(conditions)" do
it "should return first model matching conditions, if it exists" do
user = create_model(user_class, :name => "Fred")
user_adapter.find_first(:name => "Fred").should == user
end
it "should return nil if no conditions match" do
user_adapter.find_first(:name => "Betty").should == nil
end
it 'should return the first model if no conditions passed' do
user = create_model(user_class)
create_model(user_class)
user_adapter.find_first.should == user
end
it "when conditions contain associated object, should return first model if it exists" do
user = create_model(user_class)
note = create_model(note_class, :owner => user)
note_adapter.find_first(:owner => user).should == note
end
it "understands :id as a primary key condition (allowing scoped finding)" do
create_model(user_class, :name => "Fred")
user = create_model(user_class, :name => "Fred")
user_adapter.find_first(:id => user.id, :name => "Fred").should == user
user_adapter.find_first(:id => user.id, :name => "Not Fred").should be_nil
end
end
describe "(:order => <order array>)" do
it "should return first model in specified order" do
user1 = create_model(user_class, :name => "Fred", :rating => 1)
user2 = create_model(user_class, :name => "Fred", :rating => 2)
user_adapter.find_first(:order => [:name, [:rating, :desc]]).should == user2
end
end
describe "(:conditions => <conditions hash>, :order => <order array>)" do
it "should return first model matching conditions, in specified order" do
user1 = create_model(user_class, :name => "Fred", :rating => 1)
user2 = create_model(user_class, :name => "Fred", :rating => 2)
user_adapter.find_first(:conditions => {:name => "Fred"}, :order => [:rating, :desc]).should == user2
end
end
end
describe "#find_all" do
describe "(conditions)" do
it "should return only models matching conditions" do
user1 = create_model(user_class, :name => "Fred")
user2 = create_model(user_class, :name => "Fred")
user3 = create_model(user_class, :name => "Betty")
user_adapter.find_all(:name => "Fred").should == [user1, user2]
end
it "should return all models if no conditions passed" do
user1 = create_model(user_class, :name => "Fred")
user2 = create_model(user_class, :name => "Fred")
user3 = create_model(user_class, :name => "Betty")
user_adapter.find_all.should == [user1, user2, user3]
end
it "should return empty array if no conditions match" do
user_adapter.find_all(:name => "Fred").should == []
end
it "when conditions contain associated object, should return first model if it exists" do
user1, user2 = create_model(user_class), create_model(user_class)
note1 = create_model(note_class, :owner => user1)
note2 = create_model(note_class, :owner => user2)
note_adapter.find_all(:owner => user2).should == [note2]
end
end
describe "(:order => <order array>)" do
it "should return all models in specified order" do
user1 = create_model(user_class, :name => "Fred", :rating => 1)
user2 = create_model(user_class, :name => "Fred", :rating => 2)
user3 = create_model(user_class, :name => "Betty", :rating => 1)
user_adapter.find_all(:order => [:name, [:rating, :desc]]).should == [user3, user2, user1]
end
end
describe "(:conditions => <conditions hash>, :order => <order array>)" do
it "should return only models matching conditions, in specified order" do
user1 = create_model(user_class, :name => "Fred", :rating => 1)
user2 = create_model(user_class, :name => "Fred", :rating => 2)
user3 = create_model(user_class, :name => "Betty", :rating => 1)
user_adapter.find_all(:conditions => {:name => "Fred"}, :order => [:rating, :desc]).should == [user2, user1]
end
end
describe "(:limit => <number of items>)" do
it "should return a limited set of matching models" do
user1 = create_model(user_class, :name => "Fred", :rating => 1)
user2 = create_model(user_class, :name => "Fred", :rating => 2)
user3 = create_model(user_class, :name => "Betty", :rating => 1)
user_adapter.find_all(:limit => 1).should == [user1]
user_adapter.find_all(:limit => 2).should == [user1, user2]
end
end
describe "(:offset => <offset number>) with limit (as DataMapper doesn't allow offset on its own)" do
it "should return an offset set of matching models" do
user1 = create_model(user_class, :name => "Fred", :rating => 1)
user2 = create_model(user_class, :name => "Fred", :rating => 2)
user3 = create_model(user_class, :name => "Betty", :rating => 1)
user_adapter.find_all(:limit => 3, :offset => 0).should == [user1, user2, user3]
user_adapter.find_all(:limit => 3, :offset => 1).should == [user2, user3]
user_adapter.find_all(:limit => 1, :offset => 1).should == [user2]
end
end
end
describe "#create!(attributes)" do
it "should create a model with the passed attributes" do
user = user_adapter.create!(:name => "Fred")
reload_model(user).name.should == "Fred"
end
it "should raise error when create fails" do
lambda { user_adapter.create!(:user => create_model(note_class)) }.should raise_error
end
it "when attributes contain an associated object, should create a model with the attributes" do
user = create_model(user_class)
note = note_adapter.create!(:owner => user)
reload_model(note).owner.should == user
end
it "when attributes contain an has_many assoc, should create a model with the attributes" do
notes = [create_model(note_class), create_model(note_class)]
user = user_adapter.create!(:notes => notes)
reload_model(user).notes.should == notes
end
end
describe "#destroy(instance)" do
it "should destroy the instance if it exists" do
user = create_model(user_class)
user_adapter.destroy(user).should be_true
user_adapter.get(user.id).should be_nil
end
it "should return nil if passed with an invalid instance" do
user_adapter.destroy("nonexistent instance").should be_nil
end
it "should not destroy the instance if it doesn't match the model class" do
user = create_model(user_class)
note_adapter.destroy(user).should be_nil
user_adapter.get(user.id).should == user
end
end
end
end
|
