lazy_resource 0.1.0

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.
@@ -0,0 +1,169 @@
1
+ require 'spec_helper'
2
+
3
+ describe LazyResource::Relation do
4
+ before :each do
5
+ LazyResource::HttpMock.respond_to do |responder|
6
+ responder.get('http://example.com', '')
7
+ responder.get('http://example.com/users', '')
8
+ end
9
+ end
10
+
11
+ describe '#new' do
12
+ it 'adds itself to the resource queue' do
13
+ users = LazyResource::Relation.new(User)
14
+ users.resource_queue.instance_variable_get("@queue").include?(users).should == true
15
+ end
16
+
17
+ it 'does not add itself to the resource queue if fetched' do
18
+ users = LazyResource::Relation.new(User, :fetched => true)
19
+ users.resource_queue.instance_variable_get("@queue").include?(users).should_not == true
20
+ end
21
+ end
22
+
23
+ describe '#load' do
24
+ it 'loads the objects passed' do
25
+ users = [{ :id => '1', :name => 'Andrew' }, { :id => '1', :name => 'James' }]
26
+ users_collection = LazyResource::Relation.new(User)
27
+ users_collection.load(users)
28
+ users_collection.to_a.should == User.load(users)
29
+ end
30
+ end
31
+
32
+ describe '#as_json' do
33
+ it 'returns the relation as an array of hashes' do
34
+ users = [User.load(:id => 1, :name => 'Andrew'), User.load(:id => 2, :name => 'James')]
35
+ users_collection = LazyResource::Relation.new(User, :fetched => true)
36
+ users_collection.load(users)
37
+ users_collection.as_json.should == [{ :id => 1, :name => 'Andrew' }, { :id => 2, :name => 'James' }]
38
+ end
39
+ end
40
+
41
+ describe '.resource_queue' do
42
+ it 'creates a new resource queue if one does not already exist' do
43
+ LazyResource::Relation.resource_queue.should_not be_nil
44
+ end
45
+ end
46
+
47
+ describe '#collection_name' do
48
+ it 'should return the collection name from the klass' do
49
+ relation = LazyResource::Relation.new(User)
50
+ relation.collection_name.should == User.collection_name
51
+ end
52
+ end
53
+
54
+ describe '#where' do
55
+ it 'sets the where values if none exist' do
56
+ relation = LazyResource::Relation.new(User)
57
+ relation.where(:name => 'Andrew')
58
+ relation.where_values.should == { :name => 'Andrew' }
59
+ end
60
+
61
+ it 'merges where values' do
62
+ relation = LazyResource::Relation.new(User, :where_values => { :id => 123 })
63
+ relation.where(:name => 'Andrew')
64
+ relation.where_values.should == { :id => 123, :name => 'Andrew' }
65
+ end
66
+
67
+ it 'overwrites values' do
68
+ relation = LazyResource::Relation.new(User, :where_values => { :name => 'Andrew' })
69
+ relation.where(:name => 'James')
70
+ relation.where_values.should == { :name => 'James' }
71
+ end
72
+ end
73
+
74
+ describe '#order' do
75
+ it 'sets the order value if none exists' do
76
+ relation = LazyResource::Relation.new(User)
77
+ relation.order('created_at')
78
+ relation.order_value.should == 'created_at'
79
+ end
80
+
81
+ it 'overwrites the order value' do
82
+ relation = LazyResource::Relation.new(User, :order_value => 'created_at')
83
+ relation.order('name')
84
+ relation.order_value.should == 'name'
85
+ end
86
+ end
87
+
88
+ describe '#limit' do
89
+ it 'sets the limit value if none exists' do
90
+ relation = LazyResource::Relation.new(User)
91
+ relation.limit(10)
92
+ relation.limit_value.should == 10
93
+ end
94
+
95
+ it 'overwrites the order value' do
96
+ relation = LazyResource::Relation.new(User, :limit_value => 10)
97
+ relation.limit(100)
98
+ relation.limit_value.should == 100
99
+ end
100
+ end
101
+
102
+ describe '#offset' do
103
+ it 'sets the offset value if none exists' do
104
+ relation = LazyResource::Relation.new(User)
105
+ relation.offset(10)
106
+ relation.offset_value.should == 10
107
+ end
108
+
109
+ it 'overwrites the limit value' do
110
+ relation = LazyResource::Relation.new(User, :offset_value => 10)
111
+ relation.offset(20)
112
+ relation.offset_value.should == 20
113
+ end
114
+ end
115
+
116
+ describe '#page' do
117
+ it 'sets the page value if none exists' do
118
+ relation = LazyResource::Relation.new(User)
119
+ relation.page(10)
120
+ relation.page_value.should == 10
121
+ end
122
+
123
+ it 'overwrites the page value' do
124
+ relation = LazyResource::Relation.new(User, :page_value => 10)
125
+ relation.page(20)
126
+ relation.page_value.should == 20
127
+ end
128
+ end
129
+
130
+ describe 'chaining' do
131
+ it 'supports chaining' do
132
+ relation = LazyResource::Relation.new(User)
133
+ relation.where(:name => 'Andrew').order('created_at').limit(10).offset(10).page(10)
134
+ relation.where_values.should == { :name => 'Andrew' }
135
+ relation.order_value.should == 'created_at'
136
+ relation.limit_value.should == 10
137
+ relation.offset_value.should == 10
138
+ relation.page_value.should == 10
139
+ end
140
+ end
141
+
142
+ describe '#to_params' do
143
+ it 'wraps up the where, order, limit, offset, and page values into a hash' do
144
+ params = { :where_values => { :name => 'Andrew' }, :order_value => 'created_at', :limit_value => 10, :offset_value => 10, :page_value => 10 }
145
+ relation = LazyResource::Relation.new(User, params)
146
+ relation.to_params.should == { :name => 'Andrew', :order => 'created_at', :limit => 10, :offset => 10, :page => 10 }
147
+ end
148
+ end
149
+
150
+ describe '#respond_to?' do
151
+ it 'returns true if array responds to the method' do
152
+ relation = LazyResource::Relation.new(User)
153
+ relation.respond_to?(:[]).should == true
154
+ end
155
+ end
156
+
157
+ describe '#method_missing' do
158
+ it 'acts like an array' do
159
+ relation = LazyResource::Relation.new(User)
160
+ relation.should_receive(:to_a).and_return([])
161
+ relation.method_missing(:[], 0)
162
+ end
163
+
164
+ it 'raises an error if a non-array method is called' do
165
+ relation = LazyResource::Relation.new(User)
166
+ lambda { relation.foo }.should raise_error(NoMethodError)
167
+ end
168
+ end
169
+ end
@@ -0,0 +1,143 @@
1
+ require 'spec_helper'
2
+
3
+ class SampleResource
4
+ include LazyResource::Resource
5
+
6
+ attribute :id, Fixnum
7
+ attribute :name, String
8
+ attribute :created_at, DateTime
9
+ end
10
+
11
+ describe LazyResource::Request do
12
+ describe '#new' do
13
+ before :each do
14
+ LazyResource::HttpMock.respond_to do |responder|
15
+ responder.get('http://example.com/api', '')
16
+ end
17
+ end
18
+
19
+ after :each do
20
+ Thread.current[:default_headers] = nil
21
+ end
22
+
23
+ it 'sets a default Accept header of application/json' do
24
+ request = LazyResource::Request.new('http://example.com/api', nil)
25
+ headers = request.send(:instance_variable_get, "@headers")
26
+ headers[:Accept].should == 'application/json'
27
+ end
28
+
29
+ it 'sets the default method of GET' do
30
+ request = LazyResource::Request.new('http://example.com/api', nil)
31
+ request.send(:instance_variable_get, "@method").should == :get
32
+ end
33
+
34
+ it 'merges the headers from the current thread' do
35
+ Thread.current[:default_headers] = { :"X-Access-Token" => 'abc' }
36
+ request = LazyResource::Request.new('http://example.com/api', nil)
37
+ headers = request.send(:instance_variable_get, "@headers")
38
+ headers[:"X-Access-Token"].should == 'abc'
39
+ end
40
+ end
41
+
42
+ describe '#on_complete_proc' do
43
+ it 'raises an error unless 200 or 201' do
44
+ request = LazyResource::Request.new('http://example.com', nil)
45
+ response = Typhoeus::Response.new(:code => 404, :headers => {}, :body => '', :time => 0.3)
46
+ lambda { request.on_complete_proc.call(response) }.should raise_error(LazyResource::ConnectionError)
47
+ end
48
+
49
+ it 'does not raise an error on 200' do
50
+ request = LazyResource::Request.new('http://example.com', SampleResource.new)
51
+ response = Typhoeus::Response.new(:code => 200)
52
+ lambda { request.on_complete_proc.call(response) }.should_not raise_error(StandardError)
53
+ end
54
+
55
+ it 'does not raise an error on 201' do
56
+ request = LazyResource::Request.new('http://example.com', SampleResource.new)
57
+ response = Typhoeus::Response.new(:code => 201)
58
+ lambda { request.on_complete_proc.call(response) }.should_not raise_error(StandardError)
59
+ end
60
+ end
61
+
62
+ describe '#parse' do
63
+ describe 'single resources' do
64
+ it 'parses JSON and loads it onto the resource' do
65
+ request = LazyResource::Request.new('http://example.com', SampleResource.new)
66
+ response_options = {
67
+ :code => 200,
68
+ :body => {
69
+ :id => 1,
70
+ :name => "Andrew",
71
+ :created_at => "2012-08-01 00:00:00 -0500"
72
+ }.to_json,
73
+ :time => 0.3
74
+ }
75
+ response = Typhoeus::Response.new(response_options)
76
+ request.response = response
77
+ request.parse
78
+ request.resource.id.should == 1
79
+ request.resource.name.should == 'Andrew'
80
+ request.resource.created_at.should == DateTime.parse("2012-08-01 00:00:00 -0500")
81
+ end
82
+ end
83
+
84
+ describe 'resource collections' do
85
+ it 'parses JSON and loads it onto the resource' do
86
+ request = LazyResource::Request.new('http://example.com', LazyResource::Relation.new(SampleResource))
87
+ response_options = {
88
+ :code => 200,
89
+ :body => [{
90
+ :id => 1,
91
+ :name => 'Andrew',
92
+ :created_at => '2012-08-01 00:00:00 -0500'
93
+ }, {
94
+ :id => 2,
95
+ :name => 'James',
96
+ :created_at => '2012-07-01 00:00:00 -0500'
97
+ }].to_json,
98
+ :time => 0.3
99
+ }
100
+ response = Typhoeus::Response.new(response_options)
101
+ request.response = response
102
+ request.parse
103
+ users = request.resource.to_a
104
+ users.map(&:id).should == [1,2]
105
+ users.map(&:name).should == ['Andrew', 'James']
106
+ users.map(&:created_at).should == [DateTime.parse('2012-08-01 00:00:00 -0500'), DateTime.parse('2012-07-01 00:00:00 -0500')]
107
+ end
108
+ end
109
+ end
110
+
111
+ describe '#handle_errors' do
112
+ [
113
+ [301, LazyResource::Redirection],
114
+ [400, LazyResource::BadRequest],
115
+ [401, LazyResource::UnauthorizedAccess],
116
+ [403, LazyResource::ForbiddenAccess],
117
+ [404, LazyResource::ResourceNotFound],
118
+ [405, LazyResource::MethodNotAllowed],
119
+ [409, LazyResource::ResourceConflict],
120
+ [410, LazyResource::ResourceGone],
121
+ [422, LazyResource::UnprocessableEntity],
122
+ [500, LazyResource::ServerError]
123
+ ].each do |error|
124
+ describe "status: #{error[0]}" do
125
+ it "raises #{error[1]}" do
126
+ request = LazyResource::Request.new('http://example.com', nil)
127
+ response = Typhoeus::Response.new(:code => error[0], :headers => {}, :body => '', :time => 0.3)
128
+ request.response = response
129
+ lambda { request.handle_errors }.should raise_error(error[1])
130
+ end
131
+ end
132
+ end
133
+
134
+ describe 'status: 4xx' do
135
+ it 'raises ClientError' do
136
+ request = LazyResource::Request.new('http://example.com', nil)
137
+ response = Typhoeus::Response.new(:code => 402, :headers => {}, :body => '', :time => 0.3)
138
+ request.response = response
139
+ lambda { request.handle_errors }.should raise_error(LazyResource::ClientError)
140
+ end
141
+ end
142
+ end
143
+ end
@@ -0,0 +1,66 @@
1
+ require 'spec_helper'
2
+
3
+ describe LazyResource::ResourceQueue do
4
+ before :each do
5
+ @queue = LazyResource::ResourceQueue.new
6
+ @relation = LazyResource::Relation.new(User)
7
+ end
8
+
9
+ after :each do
10
+ Thread.current[:request_queue] = nil
11
+ @queue.flush!
12
+ end
13
+
14
+ describe '#queue' do
15
+ it 'queues a relation' do
16
+ @queue.queue(@relation)
17
+ @queue.instance_variable_get("@queue").should include(@relation)
18
+ end
19
+ end
20
+
21
+ describe '#flush!' do
22
+ it 'flushes the request queue without processing any of the resources' do
23
+ LazyResource::Request.should_not_receive(:new)
24
+ @queue.queue(@relation)
25
+ @queue.flush!
26
+ @queue.instance_variable_get("@queue").should == []
27
+ end
28
+ end
29
+
30
+ describe '#request_queue' do
31
+ it 'creates a new Hydra queue on the current thread' do
32
+ Typhoeus::Hydra.should_receive(:new)
33
+ @queue.request_queue.should == Thread.current[:request_queue]
34
+ end
35
+ end
36
+
37
+ describe '#run' do
38
+ before :each do
39
+ LazyResource::HttpMock.respond_to do |responder|
40
+ responder.get('http://example.com/users', '')
41
+ end
42
+ end
43
+
44
+ it 'sends the requests to the request queue and runs the request queue' do
45
+ @queue.queue(@relation)
46
+ @queue.should_receive(:send_to_request_queue!)
47
+ @queue.request_queue.should_receive(:run)
48
+ @queue.run
49
+ end
50
+ end
51
+
52
+ describe '#send_to_request_queue!' do
53
+ it 'creates requests for the relations in the queue and puts them in the request_queue' do
54
+ @queue.request_queue.should_receive(:queue)
55
+ @queue.queue(@relation)
56
+ @queue.send_to_request_queue!
57
+ @queue.instance_variable_get("@queue").should == []
58
+ end
59
+ end
60
+
61
+ describe '#url_for' do
62
+ it 'creates a URL for the given resource' do
63
+ @queue.url_for(@relation).should == 'http://example.com/users'
64
+ end
65
+ end
66
+ end
@@ -0,0 +1,463 @@
1
+ require 'spec_helper'
2
+
3
+ class Admin < User; end
4
+
5
+ describe LazyResource::Resource do
6
+ before :each do
7
+ Thread.current[:request_queue].clear_stubs unless Thread.current[:request_queue].nil?
8
+ end
9
+
10
+ describe '#new' do
11
+ it 'creates an object with the specified attributes' do
12
+ user = User.new({ :name => 'Andrew', :id => 123 })
13
+ user.name.should == 'Andrew'
14
+ user.id.should == 123
15
+ end
16
+ end
17
+
18
+ describe '#==' do
19
+ it 'returns true if the objects have the same type and data' do
20
+ user1 = User.new(:name => 'Andrew', :id => 123)
21
+ user2 = User.new(:name => 'Andrew', :id => 123)
22
+ user1.should == user2
23
+ end
24
+
25
+ it 'returns false if the objects do not have the same type' do
26
+ user = User.new(:name => 'Andrew')
27
+ admin = Admin.new(:name => 'Andrew')
28
+ user.should_not == admin
29
+ end
30
+
31
+ it 'returns false if the objects do not have the same data' do
32
+ user1 = User.new(:name => 'Andrew')
33
+ user2 = User.new(:name => 'James')
34
+ user1.should_not == user2
35
+ end
36
+ end
37
+
38
+ describe '#eql?' do
39
+ it 'returns true if the objects have the same type and data' do
40
+ user1 = User.new(:name => 'Andrew', :id => 123)
41
+ user2 = User.new(:name => 'Andrew', :id => 123)
42
+ user1.eql?(user2).should == true
43
+ end
44
+
45
+ it 'returns false if the objects do not have the same type' do
46
+ user = User.new(:name => 'Andrew')
47
+ admin = Admin.new(:name => 'Andrew')
48
+ user.eql?(admin).should == false
49
+ end
50
+
51
+ it 'returns false if the objects do not have the same data' do
52
+ user1 = User.new(:name => 'Andrew')
53
+ user2 = User.new(:name => 'James')
54
+ user1.eql?(user2).should == false
55
+ end
56
+ end
57
+
58
+ describe '#new_record?' do
59
+ it 'returns true if the record is new' do
60
+ user = User.new(:name => 'Andrew')
61
+ user.new_record?.should == true
62
+ end
63
+
64
+ it 'returns false if the record is not new' do
65
+ user = User.load(:name => 'Andrew')
66
+ user.new_record?.should == false
67
+ end
68
+ end
69
+
70
+ describe '#persisted?' do
71
+ it 'returns true if the record is persisted (exists on the server)' do
72
+ user = User.load(:name => 'Andrew')
73
+ user.persisted?.should == true
74
+ end
75
+
76
+ it 'returns false if the record is not persisted' do
77
+ user = User.new(:name => 'Andrew')
78
+ user.persisted?.should == false
79
+ end
80
+ end
81
+
82
+ describe '#save' do
83
+ describe 'new record' do
84
+ before :each do
85
+ LazyResource::HttpMock.respond_to do |responder|
86
+ responder.post('http://example.com/users', '{ "name": "Andrew" }')
87
+ end
88
+ end
89
+
90
+ it 'calls #create' do
91
+ user = User.new(:name => 'Andrew')
92
+ user.should_receive(:create)
93
+ user.save
94
+ end
95
+ end
96
+
97
+ describe 'persisted record' do
98
+ before :each do
99
+ LazyResource::HttpMock.respond_to do |responder|
100
+ responder.put('http://example.com/users/1', '{ "name": "Andrew" }')
101
+ end
102
+ end
103
+
104
+ it 'calls #update' do
105
+ user = User.load(:name => 'Andrew')
106
+ user.name = 'James'
107
+ user.should_receive(:update)
108
+ user.save
109
+ end
110
+ end
111
+ end
112
+
113
+ describe '#create' do
114
+ before :each do
115
+ LazyResource::HttpMock.respond_to do |responder|
116
+ responder.post('http://example.com/users', '{ "name": "Andrew" }')
117
+ end
118
+ end
119
+
120
+ it 'issues a POST request with the set attributes' do
121
+ user = User.new(:name => 'Andrew')
122
+ params = ['http://example.com/users', user, {
123
+ :method => :post,
124
+ :params => { :user => { 'name' => 'Andrew' } }
125
+ }]
126
+ request = LazyResource::Request.new(*params)
127
+ LazyResource::Request.should_receive(:new).with(*params).and_return(request)
128
+ user.create
129
+ end
130
+
131
+ it 'resets the dirty attributes' do
132
+ user = User.new(:name => 'Andrew')
133
+ params = ['http://example.com/users', user, {
134
+ :method => :post,
135
+ :params => { :user => { 'name' => 'Andrew' } }
136
+ }]
137
+ user.create
138
+ user.changed?.should == false
139
+ user.changed_attributes.should == {}
140
+ end
141
+ end
142
+
143
+ describe '#update' do
144
+ before :each do
145
+ LazyResource::HttpMock.respond_to do |responder|
146
+ responder.put('http://example.com/users/1', '{ "name": "James" }')
147
+ end
148
+ end
149
+
150
+ it 'issues a PUT request with the set attributes' do
151
+ user = User.load(:name => 'Andrew', :id => 1)
152
+ user.name = 'James'
153
+ params = ['http://example.com/users/1', user, {
154
+ :method => :put,
155
+ :params => { :user => { 'name' => 'James' } }
156
+ }]
157
+ request = LazyResource::Request.new(*params)
158
+ LazyResource::Request.should_receive(:new).with(*params).and_return(request)
159
+ user.update
160
+ end
161
+ end
162
+
163
+ describe '#destroy' do
164
+ before :each do
165
+ LazyResource::HttpMock.respond_to do |responder|
166
+ responder.delete('http://example.com/users/1', '')
167
+ end
168
+ end
169
+
170
+ it 'issues a DELETE request to the resource\'s element url' do
171
+ user = User.load(:name => 'Andrew', :id => 1)
172
+ params = ['http://example.com/users/1', user, {
173
+ :method => :delete
174
+ }]
175
+ request = LazyResource::Request.new(*params)
176
+ LazyResource::Request.should_receive(:new).with(*params).and_return(request)
177
+ user.destroy
178
+ end
179
+ end
180
+
181
+ describe '#update_attributes' do
182
+ before :each do
183
+ LazyResource::HttpMock.respond_to do |responder|
184
+ responder.put('http://example.com/users/1', '')
185
+ end
186
+ end
187
+
188
+ it 'issues a PUT request to the resource\'s element url with the updated attributes' do
189
+ user = User.load(:name => 'Andrew', :id => 1)
190
+ params = ['http://example.com/users/1', user, {
191
+ :method => :put,
192
+ :params => { :user => { 'name' => 'James' } }
193
+ }]
194
+ request = LazyResource::Request.new(*params)
195
+ LazyResource::Request.should_receive(:new).with(*params).and_return(request)
196
+ user.update_attributes(:name => 'James')
197
+ end
198
+
199
+ it 'updates the local attributes' do
200
+ user = User.load(:name => 'Andrew', :id => 1)
201
+ user.update_attributes(:name => 'James')
202
+ user.name.should == 'James'
203
+ end
204
+ end
205
+
206
+ describe '#attribute_params' do
207
+ it 'returns a hash of all of the changed attributes' do
208
+ user = User.new(:name => 'Andrew')
209
+ user.attribute_params.should == { :user => { 'name' => 'Andrew' } }
210
+ end
211
+ end
212
+
213
+ describe '#as_json' do
214
+ it 'returns the resource as a hash' do
215
+ user = User.load(:id => 1, :name => 'Andrew')
216
+ user.as_json.should == { :id => 1, :name => 'Andrew' }
217
+ end
218
+
219
+ it 'converts associations to hashes' do
220
+ params = { :id => 1, :name => 'Andrew', :post => { :id => 1 }, :comments => [{ :id => 1 }, { :id => 2 }] }
221
+ user = User.load(params)
222
+ user.as_json.should == params
223
+ end
224
+
225
+ it 'converts datetimes to strings' do
226
+ params = { :id => 1, :created_at => DateTime.now.to_s }
227
+ user = User.load(params)
228
+ user.as_json.should == params
229
+ end
230
+ end
231
+
232
+ describe '.find' do
233
+ before :each do
234
+ LazyResource::HttpMock.respond_to do |responder|
235
+ responder.get('http://example.com/users/1', { :name => 'Andrew' }.to_json)
236
+ end
237
+ end
238
+
239
+ it 'generates a new resource and associated request and adds it to the request queue' do
240
+ LazyResource::Request.should_receive(:new)
241
+ User.request_queue.should_receive(:queue)
242
+ user = User.find(1)
243
+ user.fetched?.should == false
244
+ end
245
+
246
+ it 'sets the primary key' do
247
+ user = User.find(1)
248
+ user.id.should == 1
249
+ user.primary_key.should == 1
250
+ end
251
+
252
+ it 'finds the object' do
253
+ user = User.find(1)
254
+ user.name.should == 'Andrew'
255
+ end
256
+ end
257
+
258
+ describe '.where' do
259
+ it 'creates a new relation with the passed where values' do
260
+ users = User.where(:name => 'Andrew')
261
+ users.where_values.should == { :name => 'Andrew' }
262
+ end
263
+ end
264
+
265
+ describe '.order' do
266
+ it 'creates a new relation with the passed order value' do
267
+ users = User.order('created_at')
268
+ users.order_value.should == 'created_at'
269
+ end
270
+ end
271
+
272
+ describe '.limit' do
273
+ it 'creates a new relation with the passed limit value' do
274
+ users = User.limit(10)
275
+ users.limit_value.should == 10
276
+ end
277
+ end
278
+
279
+ describe '.offset' do
280
+ it 'creates a new relation with the passed offset' do
281
+ users = User.offset(10)
282
+ users.offset_value.should == 10
283
+ end
284
+ end
285
+
286
+ describe '.page' do
287
+ it 'creates a new relation with the passed page' do
288
+ users = User.page(3)
289
+ users.page_value.should == 3
290
+ end
291
+ end
292
+
293
+ describe '.all' do
294
+ it 'creates a new relation with no options' do
295
+ users = User.all
296
+ users.where_values.should be_nil
297
+ end
298
+ end
299
+
300
+ describe '.create' do
301
+ before :each do
302
+ LazyResource::HttpMock.respond_to do |responder|
303
+ responder.post 'http://example.com/users', '{ "name": "Andrew", "id": 1 }'
304
+ end
305
+ end
306
+
307
+ it 'instantiates a new record with the passed values' do
308
+ user = User.create(:name => 'Andrew')
309
+ user.name.should == 'Andrew'
310
+ end
311
+
312
+ it 'issues a POST request with the passed parameters' do
313
+ user = User.new(:name => 'Andrew')
314
+ params = ['http://example.com/users', user, {
315
+ :method => :post,
316
+ :params => { :user => { 'name' => 'Andrew' } }
317
+ }]
318
+ request = LazyResource::Request.new(*params)
319
+ LazyResource::Request.should_receive(:new).with(*params).and_return(request)
320
+ User.create(:name => 'Andrew')
321
+ end
322
+ end
323
+
324
+ describe '.site' do
325
+ before :each do
326
+ @site = User.site
327
+ end
328
+
329
+ after :each do
330
+ User.site = @site
331
+ end
332
+
333
+ it 'returns the site if it is defined' do
334
+ User.site = 'http://github.com'
335
+ User.site.should == 'http://github.com'
336
+ end
337
+
338
+ it 'returns LazyResource::Resource.site if site is not defined' do
339
+ User.send(:remove_instance_variable, "@site")
340
+ User.site.should == LazyResource::Resource.site
341
+ end
342
+ end
343
+
344
+ describe '.site=' do
345
+ before :each do
346
+ @site = User.site
347
+ end
348
+
349
+ after :each do
350
+ User.site = @site
351
+ end
352
+
353
+ it 'sets the site' do
354
+ User.site = 'http://github.com'
355
+ User.site.should == 'http://github.com'
356
+ end
357
+ end
358
+
359
+ describe '.root_node_name=' do
360
+ before :each do
361
+ LazyResource::Mapping.root_node_name = nil
362
+ end
363
+
364
+ it 'sets the root node name of the Mapping module' do
365
+ LazyResource::Resource.root_node_name = 'data'
366
+ LazyResource::Mapping.root_node_name.should == 'data'
367
+ end
368
+ end
369
+
370
+ describe '.resource_queue' do
371
+ before :each do
372
+ Thread.current[:request_queue] = nil
373
+ end
374
+
375
+ after :each do
376
+ Thread.current[:resource_queue] = nil
377
+ end
378
+
379
+ it 'creates a new Hydra queue on the current thread' do
380
+ Typhoeus::Hydra.should_receive(:new)
381
+ User.request_queue.should == Thread.current[:request_queue]
382
+ end
383
+ end
384
+
385
+ describe 'callbacks' do
386
+ before :each do
387
+ LazyResource::HttpMock.respond_to do |responder|
388
+ responder.post('http://example.com/users', '')
389
+ responder.put('http://example.com/users/1', '')
390
+ responder.delete('http://example.com/users/1', '')
391
+ end
392
+ end
393
+
394
+ describe 'create' do
395
+ it 'adds a before_create callback' do
396
+ User.respond_to?(:before_create).should == true
397
+ end
398
+
399
+ it 'adds a around_create callback' do
400
+ User.respond_to?(:around_create).should == true
401
+ end
402
+
403
+ it 'adds a after_create callback' do
404
+ User.respond_to?(:after_create).should == true
405
+ end
406
+ end
407
+
408
+ describe 'update' do
409
+ it 'adds a before_update callback' do
410
+ User.respond_to?(:before_update).should == true
411
+ end
412
+
413
+ it 'adds a around_update callback' do
414
+ User.respond_to?(:around_update).should == true
415
+ end
416
+
417
+ it 'adds a after_update callback' do
418
+ User.respond_to?(:after_update).should == true
419
+ end
420
+ end
421
+
422
+ describe 'save' do
423
+ it 'adds a before_save callback' do
424
+ User.respond_to?(:before_save).should == true
425
+ end
426
+
427
+ it 'adds a around_save callback' do
428
+ User.respond_to?(:around_save).should == true
429
+ end
430
+
431
+ it 'adds a after_save callback' do
432
+ User.respond_to?(:after_save).should == true
433
+ end
434
+ end
435
+
436
+ describe 'destroy' do
437
+ it 'adds a before_destroy callback' do
438
+ User.respond_to?(:before_destroy).should == true
439
+ end
440
+
441
+ it 'adds a around_destroy callback' do
442
+ User.respond_to?(:around_destroy).should == true
443
+ end
444
+
445
+ it 'adds a after_destroy callback' do
446
+ User.respond_to?(:after_destroy).should == true
447
+ end
448
+ end
449
+ end
450
+
451
+ describe 'validations' do
452
+ class User
453
+ validates_presence_of :name
454
+ end
455
+
456
+ it 'validates' do
457
+ user = User.new
458
+ user.valid?.should == false
459
+ user.name = 'Andrew'
460
+ user.valid?.should == true
461
+ end
462
+ end
463
+ end