-
Notifications
You must be signed in to change notification settings - Fork 52
/
service_steps.rb
260 lines (201 loc) · 8.33 KB
/
service_steps.rb
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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
STANDARD_URL = "http://#{WEBSERVER}:#{HTTP_PORT_NUMBER}/SampleService/RubyOData.svc"
BASICAUTH_URL = "http://#{WEBSERVER}:#{HTTP_PORT_NUMBER}/SampleService/BasicAuth/RubyOData.svc"
HTTPS_BASICAUTH_URL = "https://#{WEBSERVER}:#{HTTPS_PORT_NUMBER}/SampleService/BasicAuth/RubyOData.svc"
When /^(.*) first (last query )?result(\'s)?(.*)$/ do |pre, last_query, apos, post|
the_step = "#{pre} #{last_query}result#{apos}#{post}"
first_result
step the_step
end
When /^(.*) first (last )?save result(.*)$/ do |pre, last, post|
the_step = "#{pre} #{last}save result#{post}"
first_save
step the_step
end
Given /^a HTTP ODataService exists$/ do
VCR.use_cassette("unsecured_metadata") do
@service = OData::Service.new(STANDARD_URL)
end
end
Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and password "([^\"]*)"$/ do |username, password|
@service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password })
end
Given /^a HTTP BasicAuth ODataService exists using username "([^\"]*)" and password "([^\"]*)" it should throw an exception with message "([^\"]*)"$/ do |username, password, msg|
lambda { @service = OData::Service.new(BASICAUTH_URL, { :username => username, :password => password }) }.should raise_error(msg)
end
Given /^a HTTP BasicAuth ODataService exists it should throw an exception with message "([^\"]*)"$/ do |msg|
lambda { @service = OData::Service.new(BASICAUTH_URL) }.should raise_error(msg)
end
Given /^a HTTPS BasicAuth ODataService exists using self-signed certificate and username "([^\"]*)" and password "([^\"]*)"$/ do |username, password|
@service = OData::Service.new(HTTPS_BASICAUTH_URL, { :username => username, :password => password, :verify_ssl => false })
end
When /^I call "([^\"]*)" on the service$/ do |method|
@service_query = @service.send(method)
end
Then /^the integer result should be ([^\"]*)$/ do |result|
@service_result.should eq result.to_i
end
Then /^I should be able to call "([^\"]*)" on the service$/ do |method|
lambda { @service.send(method) }.should_not raise_error
end
Then /^I should not be able to call "([^\"]*)" on the service$/ do |method|
lambda { @service.send(method) }.should raise_error
end
Then /^I should be able to call "([^\"]*)" on the service with args: "([^\"]*)"$/ do |method, args|
lambda { @service.send(method, args) }.should_not raise_error
end
When /^I call "([^\"]*)" on the service with args: "([^\"]*)"$/ do |method, args|
@service_query = @service.send(method, args)
end
When /^I run the query$/ do
@service_result = @service.execute
end
Then /^the result should be of type "([^\"]*)"$/ do |type|
@service_result.class.to_s.should eq type
end
Then /^the result should have a method: "([^\"]*)"$/ do |method|
@service_result.respond_to?(method.to_sym).should eq true
end
Then /^the method "([^\"]*)" on the result should equal: "([^\"]*)"$/ do |method, value|
@service_result.send(method.to_sym).to_s.should eq value
end
Then /^the method "([^\"]*)" on the result should be nil$/ do |method|
@service_result.send(method.to_sym).should eq nil
end
When /^I set "([^\"]*)" on the result to "([^\"]*)"$/ do |property_name, value|
@service_result.send("#{property_name}=", value)
end
Given /^I expand the query to include "([^\"]*)"$/ do |expands|
@service_query.expand(expands)
end
When /^I filter the query with: "([^\"]*)"$/ do |filter|
@service_query.filter(filter)
end
When /^I order by: "([^\"]*)"$/ do |order|
@service_query.order_by(order)
end
When /^I skip (\d+)$/ do |skip|
@service_query.skip(skip)
end
When /^I ask for the top (\d+)$/ do |top|
@service_query.top(top)
end
When /^I ask for the count$/ do
@service_query.count
end
When /^I ask for the links for "([^\"]*)"$/ do |nav_prop|
@service_query.links(nav_prop)
end
Then /^the method "([^\"]*)" on the result should be of type "([^\"]*)"$/ do |method, type|
result = @service_result.send(method.to_sym)
result.class.to_s.should eq type
end
Given /^I call "([^\"]*)" on the service with a new "([^\"]*)" object(?: with (.*))?$/ do |method, object, fields|
fields_hash = parse_fields_string(fields)
obj = object.constantize.send(:make, fields_hash)
@service.send(method.to_sym, obj)
end
When /^I save changes$/ do
@saved_result = @service.save_changes
end
Then /^the save result should be of type "([^\"]*)"$/ do |type|
@saved_result.class.to_s.should eq type
end
When /^I call "([^\"]*)" on the service with the last save result$/ do |method|
@service.send(method.to_sym, @saved_result)
end
When /^I call "([^\"]*)" on the service with the last query result$/ do |method|
@service.send(method.to_sym, @service_result)
end
Then /^the save result should equal: "([^\"]*)"$/ do |result|
@saved_result.to_s.should eq result
end
Then /^the method "([^\"]*)" on the save result should equal: "([^\"]*)"$/ do |method, value|
result = @saved_result.send(method.to_sym)
result.should eq value
end
When /^blueprints exist for the service$/ do
require File.expand_path(File.dirname(__FILE__) + "../../../test/blueprints")
end
Given /^I call "([^\"]*)" on the service with a new "([^\"]*)" object it should throw an exception with message "([^\"]*)"$/ do |method, object, msg|
obj = object.constantize.send :make
lambda { @service.send(method.to_sym, obj) }.should raise_error(msg)
end
When /^I save changes it should throw an exception with message containing "([^"]*)"$/ do |msg|
lambda { @service.save_changes }.should raise_error(/#{msg}.*/)
end
Then /^no "([^\"]*)" should exist$/ do |collection|
@service.send(collection)
results = @service.execute
results.should eq []
end
Then /^the primitive results should be:$/ do |table|
# table is a Cucumber::Ast::Table
values = table.hashes
result_table = Cucumber::Ast::Table.new(values)
table.diff!(result_table)
end
Then /^the result should be:$/ do |table|
# table is a Cucumber::Ast::Table
fields = table.hashes[0].keys
# Build an array of hashes so that we can compare tables
results = []
@service_result.each do |result|
obj_hash = Hash.new
fields.each do |field|
obj_hash[field] = result.send(field)
end
results << obj_hash
end
result_table = Cucumber::Ast::Table.new(results)
table.diff!(result_table)
end
Then /^a class named "([^\"]*)" should exist$/ do |klass_name|
(Object.const_defined? klass_name).should eq true
end
# Operations against a method on the service result
When /^I call "([^\"]*)" for "([^\"]*)" on the result$/ do |method2, method1|
r1 = @service_result.send(method1)
@operation_result = r1.send(method2)
end
Then /^the operation should not be null$/ do
@operation_result.nil?.should eq false
end
Then /^the method "([^\"]*)" on the result's method "([^\"]*)" should equal: "([^\"]*)"$/ do |method, result_method, value|
obj = @service_result.send(result_method.to_sym)
obj.send(method.to_sym).to_s.should eq value
end
When /^I set "([^\"]*)" on the result's method "([^\"]*)" to "([^\"]*)"$/ do |property_name, result_method, value|
@service_result.send(result_method).send("#{property_name}=", value)
end
# Type tests
Then /^the "([^\"]*)" method on the object should return a (.*)/ do |method_name, type|
methods = method_name.split '.'
if methods.length == 1
@service_result.first.send(method_name).class.to_s.should eq type
else
@service_result.first.send(methods[0]).send(methods[1]).class.to_s.should eq type
end
end
Then /^I store the last query result for comparison$/ do
@stored_query_result = @service_result
end
Then /^the new query result's time "([^\"]*)" should equal the saved query result$/ do |method_name|
methods = method_name.split '.'
@service_result.send(methods[0]).send(methods[1]).xmlschema(3).should eq @stored_query_result.send(methods[0]).send(methods[1]).xmlschema(3)
end
Then /^the result count should be (\d+)$/ do |expected_count|
@service_result.count.should eq expected_count.to_i
end
When /^I add a link between #{capture_model} and #{capture_model} on "([^"]*)"$/ do |parent, child, property|
@service.add_link(created_model(parent), property, created_model(child))
end
Given /^I call the service method "([^"]*)"(?: with (.*))?$/ do |method, args|
if args
@service_result = @service.send(method, args)
else
@service_result = @service.send(method)
end
end
When /^(.*) within a cassette named "([^"]*)"$/ do |the_step, cassette_name|
VCR.use_cassette(cassette_name) { step the_step }
end