16 |
17 | [](https://github.com/makandra/cucumber_factory/actions?query=branch:master)
18 |
19 |
20 | Create ActiveRecord objects without step definitions
21 | ----------------------------------------------------
22 |
23 | cucumber_factory allows you to create ActiveRecord objects directly from your [Cucumber](http://cukes.info/) features. No step definitions required.
24 |
25 |
26 | Basic usage
27 | -----------
28 |
29 | To create a new record with default attributes, begin any step with `Given there is`:
30 |
31 | ```cucumber
32 | Given there is a movie
33 | ```
34 |
35 | To create the record, cucumber_factory will call [`FactoryBot.create(:movie)`](http://github.com/thoughtbot/factory_bot), `FactoryGirl.create(:movie)`, [`Movie.make`](http://github.com/notahat/machinist), [`Movie.create!`](http://apidock.com/rails/ActiveRecord/Persistence/ClassMethods/create%21) or `Movie.new`, depending on what's available.
36 |
37 | Quoted strings and numbers denote attribute values:
38 |
39 | ```cucumber
40 | Given there is a movie with the title "Sunshine" and the year 2007
41 | ```
42 |
43 | To update an existing record, specify the record and the changes:
44 | ```
45 | Given the movie above has the title "Sunset" and the year 2008
46 | Given the movie "Sunrise" has the year 2009
47 | ```
48 | A record can be specified by the `above` keyword, which uses the last created record of this class, or by any string that was used during its creation.
49 |
50 | Setting boolean attributes
51 | --------------------------
52 |
53 | Boolean attributes can be set by appending `which`, `that` or `who` at the end:
54 |
55 | ```cucumber
56 | Given there is a movie which is awesome
57 | And there is a movie with the name "Sunshine" that is not a comedy
58 | And there is a director who is popular
59 | ```
60 |
61 | Instead of `and` you can also use `but` and commas to join sentences:
62 |
63 | ```cucumber
64 | Given there is a movie which is awesome, popular and successful but not science fiction
65 | And there is a director with the income "500000" but with the account balance "-30000"
66 | ```
67 |
68 | To update boolean attributes use the keyword `is`:
69 |
70 | ```cucumber
71 | Given the movie above is awesome but not popular
72 | Given the movie above has the year 1979 but is not science fiction
73 | ```
74 |
75 |
76 | Setting many attributes with a table
77 | ------------------------------------
78 |
79 | If you have many attribute assignments you can use doc string or data table:
80 |
81 | ```cucumber
82 | Given there is a movie with these attributes:
83 | """
84 | name: Sunshine
85 | comedy: false
86 | """
87 | ```
88 |
89 | ```cucumber
90 | Given there is a movie with these attributes:
91 | | name | Sunshine |
92 | | comedy | false |
93 | ```
94 |
95 | ```cucumber
96 | Given the movie above has these attributes:
97 | """
98 | name: Sunshine
99 | comedy: false
100 | """
101 | ```
102 |
103 | Setting associations
104 | --------------------
105 |
106 | You can set `belongs_to` and `transient` associations by referring to the last created record of as `above`:
107 |
108 | ```cucumber
109 | Given there is a movie with the title "Before Sunrise"
110 | And there is a movie with the prequel above
111 | ```
112 |
113 | The example above also shows how to set `has_many` associations - you simply set the `belongs_to` association on the other side.
114 |
115 | You can also refer to a previously created record using any string attribute used in its creation:
116 |
117 | ```cucumber
118 | Given there is a movie with the title "Before Sunrise"
119 | And there is a movie with the title "Limitless"
120 | And there is a movie with the prequel "Before Sunrise"
121 | ```
122 |
123 | You can also explicitly give a record a name and use it to set a `belongs_to` association below:
124 |
125 | ```cucumber
126 | Given "Before Sunrise" is a movie
127 | And there is a movie with the title "Limitless"
128 | And there is a movie with the prequel "Before Sunrise"
129 | ```
130 |
131 | Note that in the example above, "Before Sunrise" is only a name you can use to refer to the record. The name is not actually used for the movie title, or any other attribute value.
132 |
133 | It is not possible to define associations in doc string or data table, but you can combine them in one
134 | step:
135 |
136 | ```cucumber
137 | Given there is a movie with the prequel above and these attributes:
138 | """
139 | name: Sunshine
140 | comedy: false
141 | """
142 | ```
143 |
144 | ```cucumber
145 | Given there is a movie with the prequel above and these attributes:
146 | | name | Sunshine |
147 | | comedy | false |
148 | ```
149 |
150 |
151 | Setting array attributes or has_many associations
152 | -------------------------------------------------
153 |
154 | You can set `has_many` associations by referring to multiple named records in square brackets:
155 |
156 | ```cucumber
157 | Given there is a movie with the title "Sunshine"
158 | And there is a movie with the title "Limitless"
159 | And there is a movie with the title "Salt"
160 | And there is a user with the favorite movies ["Sunshine", "Limitless" and "Salt"]
161 | ```
162 |
163 | When using [PostgreSQL array columns](https://www.postgresql.org/docs/9.1/static/arrays.html), you can set an array attribute to a value with square brackets:
164 |
165 | ```cucumber
166 | Given there is a movie with the tags ["comedy", "drama" and "action"]
167 | ```
168 |
169 |
170 | Setting file attributes
171 | -----------------------
172 |
173 | You can set an attribute to a file object with the following syntax:
174 |
175 | ```cucumber
176 | Given there is a movie with the image file:'path/to/image.jpg'
177 | ```
178 |
179 | All paths are relative to the project root, absolute paths are not supported. Please note that file attributes must follow the syntax `file:"PATH"`, both single and double quotes are allowed.
180 |
181 | Using named factories and traits
182 | --------------------------------
183 |
184 | You can use a [FactoryBot child factory](https://github.com/thoughtbot/factory_bot/blob/master/GETTING_STARTED.md#inheritance) or [Machinist named blueprint](https://github.com/notahat/machinist/tree/1.0-maintenance#named-blueprints) by putting the variant name in parentheses:
185 |
186 | ```cucumber
187 | Given there is a movie (comedy) with the title "Groundhog Day"
188 | ```
189 |
190 | You can use [FactoryBot traits](https://github.com/thoughtbot/factory_bot/blob/master/GETTING_STARTED.md#traits) by putting the traits in parentheses, as a comma-separated list:
191 |
192 | ```cucumber
193 | Given there is a movie (moody, dark) with the title "Interstellar"
194 | ```
195 |
196 |
197 |
198 |
199 | Overriding factory steps
200 | ------------------------
201 |
202 | If you want to override a factory step with your own version, just do so:
203 |
204 | ```ruby
205 | Given /^there is a movie with good actors$/ do
206 | movie = Movie.make
207 | movie.actors << Actor.make(:name => 'Clive Owen')
208 | movie.actors << Actor.make(:name => 'Denzel Washington')
209 | end
210 | ```
211 |
212 | Custom steps will always be preferred over factory steps. Also Cucumber will not raise a warning about ambiguous steps if the only other matching step is a factory step. Thanks, [cucumber_priority](https://github.com/makandra/cucumber_priority)!
213 |
214 |
215 | Supported Cucumber versions
216 | ----------------------------
217 |
218 | cucumber_factory is tested against Cucumber 1.3, 2.4, 3.0, 3.1, 4.1, 5.3, 9.2 and 10.1.
219 |
220 |
221 | Installation
222 | ------------
223 |
224 | In your `Gemfile` say:
225 |
226 | gem 'cucumber_factory'
227 |
228 | Now create a file `features/step_definitions/factory_steps.rb`, which just says
229 |
230 | require 'cucumber_factory/add_steps'
231 |
232 | Now run `bundle install` and restart your server.
233 |
234 |
235 | Development
236 | -----------
237 |
238 | There are tests in `spec`. We only accept PRs with tests. To run tests:
239 |
240 | - Install the Ruby version stated in `.ruby-version`
241 | - Create a local PostgreSQL database:
242 | ```
243 | $ sudo -u postgres psql -c 'create database cucumber_factory_test;'
244 | ```
245 |
246 | - Copy `spec/support/database.sample.yml` to `spec/support/database.yml` and enter your local credentials for the test databases
247 | - Install development dependencies using `bundle install`
248 | - Run tests with the default symlinked Gemfile using `bundle exec rspec` or explicit with `BUNDLE_GEMFILE=Gemfile.cucumber-x.x bundle exec rspec spec`
249 |
250 | We recommend to test large changes against multiple versions of Ruby and multiple dependency sets. Supported combinations are configured in .github/workflows/test.yml. We provide some rake tasks to help with this:
251 |
252 | For each ruby version do (you need to change it manually):
253 | - Install development dependencies using `rake matrix:install`
254 | - Run tests using `rake matrix:spec`
255 | - Shorthand:
256 | ```sh
257 | for version in "2.5.3" "2.6.6" "2.7.2" "3.2.0" "3.4.1"; do rbenv shell $version && bundle install && bundle exec rake matrix:install && bundle exec rake matrix:spec; done
258 | ```
259 |
260 | Note that we have configured GitHub Actions to automatically run tests in all supported Ruby versions and dependency sets after each push. We will only merge pull requests after a green workflow build.
261 |
262 | If you would like to contribute:
263 |
264 | - Fork the repository.
265 | - Push your changes **with passing specs**.
266 | - Send us a pull request.
267 |
268 | I'm very eager to keep this gem leightweight and on topic. If you're unsure whether a change would make it into the gem [talk to me beforehand](mailto:henning.koch@makandra.de).
269 |
270 |
271 | Credits
272 | -------
273 |
274 | Henning Koch from [makandra](https://makandra.com/)
275 |
--------------------------------------------------------------------------------
/lib/cucumber_factory/factory.rb:
--------------------------------------------------------------------------------
1 | module CucumberFactory
2 | module Factory
3 | class Error < StandardError; end
4 |
5 | ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?' # ... with the year 1979 which is science fiction
6 | TEXT_ATTRIBUTES_PATTERN = ' (?:with|and) these attributes:'
7 | UPDATE_ATTR_PATTERN = '(?: (?:has|belongs to)( the .+?)|(?: and| but|,)*( is .+?))' # ... belongs to the collection "Fantasy" and is trending
8 | TEXT_UPDATE_ATTR_PATTERN = '(?: and|,)* has these attributes:'
9 |
10 | RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?' # Given there is a movie (comedy)
11 | NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?' # Given "LotR" is a movie
12 | RECORD_UPDATE_PATTERN = 'the ([^"\',]+?) (above|".+?"|\'.+?\')' # Given the movie "LotR" ...
13 |
14 | NAMED_RECORDS_VARIABLE = :'@named_cucumber_factory_records'
15 |
16 | VALUE_INTEGER = /\d+/
17 | VALUE_DECIMAL = /[\d\.]+/
18 | VALUE_STRING = /"[^"]*"|'[^']*'/
19 | VALUE_FILE = /file:#{VALUE_STRING}/
20 | VALUE_ARRAY = /\[[^\]]*\]/
21 | VALUE_LAST_RECORD = /\babove\b/
22 |
23 | VALUE_SCALAR = /#{VALUE_STRING}|#{VALUE_DECIMAL}|#{VALUE_INTEGER}|#{VALUE_FILE}/
24 |
25 | CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR = {
26 | :kind => :Before,
27 | :block => proc { CucumberFactory::Factory.send(:reset_named_records, self) }
28 | }
29 |
30 | # We cannot use vararg blocks in the descriptors in Ruby 1.8, as explained by
31 | # Aslak: http://www.ruby-forum.com/topic/182927. We use different descriptors and cucumber priority to work around
32 | # it.
33 |
34 | NAMED_CREATION_STEP_DESCRIPTOR = {
35 | :kind => :Given,
36 | :pattern => /^#{NAMED_RECORD_PATTERN}#{ATTRIBUTES_PATTERN}?$/,
37 | :block => lambda { |a1, a2, a3, a4, a5, a6| CucumberFactory::Factory.send(:parse_named_creation, self, a1, a2, a3, a4, a5, a6) }
38 | }
39 |
40 | CREATION_STEP_DESCRIPTOR = {
41 | :kind => :Given,
42 | :pattern => /^#{RECORD_PATTERN}#{ATTRIBUTES_PATTERN}$/,
43 | :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_creation, self, a1, a2, a3, a4) }
44 | }
45 |
46 | UPDATE_STEP_DESCRIPTOR = {
47 | :kind => :And,
48 | :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}+$/,
49 | :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4) }
50 | }
51 |
52 | NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
53 | :kind => :Given,
54 | :pattern => /^#{NAMED_RECORD_PATTERN}#{ATTRIBUTES_PATTERN}#{TEXT_ATTRIBUTES_PATTERN}?$/,
55 | :block => lambda { |a1, a2, a3, a4, a5, a6, a7| CucumberFactory::Factory.send(:parse_named_creation, self, a1, a2, a3, a4, a5, a6, a7) },
56 | :priority => true
57 | }
58 |
59 | CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
60 | :kind => :Given,
61 | :pattern => /^#{RECORD_PATTERN}#{ATTRIBUTES_PATTERN}#{TEXT_ATTRIBUTES_PATTERN}$/,
62 | :block => lambda { |a1, a2, a3, a4, a5| CucumberFactory::Factory.send(:parse_creation, self, a1, a2, a3, a4, a5) },
63 | :priority => true
64 | }
65 |
66 | UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
67 | :kind => :And,
68 | :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}*#{TEXT_UPDATE_ATTR_PATTERN}$/,
69 | :block => lambda { |a1, a2, a3, a4, a5| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4, a5) },
70 | :priority => true
71 | }
72 |
73 | class << self
74 |
75 | def add_steps(main)
76 | add_step(main, CREATION_STEP_DESCRIPTOR)
77 | add_step(main, NAMED_CREATION_STEP_DESCRIPTOR)
78 | add_step(main, CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
79 | add_step(main, NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
80 | add_step(main, CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR)
81 | add_step(main, UPDATE_STEP_DESCRIPTOR)
82 | add_step(main, UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
83 | end
84 |
85 | private
86 |
87 | def add_step(main, descriptor)
88 | main.instance_eval {
89 | kind = descriptor[:kind]
90 | object = send(kind, *[descriptor[:pattern]].compact, &descriptor[:block])
91 | # cucumber_factory steps get a low priority due to their generic syntax
92 | object.overridable(:priority => descriptor[:priority] ? -1 : -2) if kind != :Before
93 | object
94 | }
95 | end
96 |
97 | def reset_named_records(world)
98 | world.instance_variable_set(NAMED_RECORDS_VARIABLE, {})
99 | end
100 |
101 | def named_records(world)
102 | hash = world.instance_variable_get(NAMED_RECORDS_VARIABLE)
103 | hash || reset_named_records(world)
104 | end
105 |
106 | def get_named_record(world, name)
107 | named_records(world)[name].tap do |record|
108 | record.reload if record.respond_to?(:reload) and record.respond_to?(:new_record?) and not record.new_record?
109 | end
110 | end
111 |
112 | def set_named_record(world, name, record)
113 | named_records(world)[name] = record
114 | end
115 |
116 | def parse_named_creation(world, double_quote_name, single_quote_name, raw_model, raw_variant, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
117 | record = parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes, raw_multiline_attributes)
118 | name = [double_quote_name, single_quote_name].compact.first
119 | set_named_record(world, name, record)
120 | end
121 |
122 | def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
123 | build_strategy, transient_attributes = CucumberFactory::BuildStrategy.from_prose(raw_model, raw_variant)
124 | model_class = build_strategy.model_class
125 | attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes, transient_attributes)
126 | record = build_strategy.create_record(attributes)
127 | remember_record_names(world, record, attributes)
128 | record
129 | end
130 |
131 | def parse_update(world, raw_model, raw_name, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
132 | model_class = CucumberFactory::BuildStrategy.parse_model_class(raw_model)
133 | attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes)
134 | record = resolve_associated_value(world, model_class, model_class, model_class, raw_name)
135 | CucumberFactory::UpdateStrategy.new(record).assign_attributes(attributes)
136 | remember_record_names(world, record, attributes)
137 | record
138 | end
139 |
140 | def parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil, transient_attributes = [])
141 | attributes = {}
142 | if raw_attributes.try(:strip).present?
143 | raw_attribute_fragment_regex = /(?:the |and |with |but |,| )+(.*?) (#{VALUE_SCALAR}|#{VALUE_ARRAY}|#{VALUE_LAST_RECORD})/
144 | raw_attributes.scan(raw_attribute_fragment_regex).each do |fragment|
145 | attribute = attribute_name_from_prose(fragment[0])
146 | value = fragment[1]
147 | attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
148 | end
149 | unused_raw_attributes = raw_attributes.gsub(raw_attribute_fragment_regex, '')
150 | if unused_raw_attributes.present?
151 | raise ArgumentError, "Unable to parse attributes #{unused_raw_attributes.inspect}."
152 | end
153 | end
154 | if raw_boolean_attributes.try(:strip).present?
155 | raw_boolean_attributes.scan(/(?:which|who|that|is| )*(not )?(.+?)(?: and | but |,|$)+/).each do |fragment|
156 | flag = !fragment[0] # if the word 'not' didn't match above, this expression is true
157 | attribute = attribute_name_from_prose(fragment[1])
158 | attributes[attribute] = flag
159 | end
160 | end
161 | if raw_multiline_attributes.present?
162 | # DocString e.g. "first name: Jane\nlast name: Jenny\n"
163 | if raw_multiline_attributes.is_a?(String)
164 | raw_multiline_attributes.split("\n").each do |fragment|
165 | raw_attribute, value = fragment.split(': ', 2)
166 | attribute = attribute_name_from_prose(raw_attribute)
167 | value = "\"#{value}\"" unless matches_fully?(value, /#{VALUE_ARRAY}|#{VALUE_FILE}/)
168 | attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
169 | end
170 | # DataTable e.g. in raw [["first name", "Jane"], ["last name", "Jenny"]]
171 | else
172 | raw_multiline_attributes.raw.each do |raw_attribute, value|
173 | attribute = attribute_name_from_prose(raw_attribute)
174 | value = "\"#{value}\"" unless matches_fully?(value, /#{VALUE_ARRAY}|#{VALUE_FILE}/)
175 | attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
176 | end
177 | end
178 | end
179 | attributes
180 | end
181 |
182 | def attribute_value(world, model_class, transient_attributes, attribute, value)
183 | associated, association_class = resolve_association(attribute, model_class, transient_attributes)
184 |
185 | value = if matches_fully?(value, VALUE_ARRAY)
186 | array_values = unquote(value).scan(VALUE_SCALAR)
187 | array_values.map { |v| attribute_value(world, model_class, transient_attributes, attribute, v) }
188 | elsif associated
189 | resolve_associated_value(world, model_class, association_class, attribute, value)
190 | else
191 | resolve_scalar_value(world, model_class, attribute, value)
192 | end
193 | value
194 | end
195 |
196 | def resolve_association(attribute, model_class, transient_attributes)
197 | return unless model_class.respond_to?(:reflect_on_association)
198 |
199 | association = model_class.reflect_on_association(attribute)
200 | association_class = nil
201 |
202 | if association
203 | association_class = association.klass unless association.polymorphic?
204 | associated = true
205 | elsif transient_attributes.include?(attribute.to_sym)
206 | klass_name = attribute.to_s.camelize
207 | if Object.const_defined?(klass_name)
208 | association_class = klass_name.constantize
209 | associated = true
210 | elsif (factory_class = CucumberFactory::BuildStrategy.class_from_factory(attribute.to_s))
211 | association_class = factory_class
212 | associated = true
213 | end
214 | else
215 | associated = false
216 | end
217 | [associated, association_class]
218 | end
219 |
220 | def resolve_associated_value(world, model_class, association_class, attribute, value)
221 | if matches_fully?(value, VALUE_LAST_RECORD)
222 | raise(Error, "Cannot set last #{model_class}##{attribute} for polymorphic associations") unless association_class.present?
223 |
224 | CucumberFactory::Switcher.find_last(association_class) || raise(Error, "There is no last #{attribute}")
225 | elsif matches_fully?(value, VALUE_STRING)
226 | value = unquote(value)
227 | get_named_record(world, value) || transform_value(world, value)
228 | elsif matches_fully?(value, VALUE_INTEGER)
229 | value = value.to_s
230 | get_named_record(world, value) || transform_value(world, value)
231 | else
232 | raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
233 | end
234 | end
235 |
236 | def resolve_scalar_value(world, model_class, attribute, value)
237 | if matches_fully?(value, VALUE_STRING)
238 | value = unquote(value)
239 | value = transform_value(world, value)
240 | elsif matches_fully?(value, VALUE_INTEGER)
241 | value = value.to_i
242 | elsif matches_fully?(value, VALUE_DECIMAL)
243 | value = BigDecimal(value)
244 | elsif matches_fully?(value, VALUE_FILE)
245 | path = File.path("./#{file_value_to_path(value)}")
246 | value = File.new(path)
247 | else
248 | raise Error, "Cannot set attribute #{model_class}##{attribute} to #{value}."
249 | end
250 | value
251 | end
252 |
253 | def unquote(string)
254 | # This method removes quotes or brackets from the start and end from a string
255 | # Examples: 'single' => single, "double" => double, [1, 2, 3] => 1, 2, 3
256 | string[1, string.length - 2]
257 | end
258 |
259 | def file_value_to_path(string)
260 | # file paths are marked with a special keyword and enclosed with quotes.
261 | # Example: file:"/path/image.png"
262 | # This will extract the path (/path/image.png) from the text fragment above
263 | unquote string.sub(/\Afile:/, '')
264 | end
265 |
266 | def full_regexp(partial_regexp)
267 | Regexp.new('\\A(?:' + partial_regexp.source + ')\\z', partial_regexp.options)
268 | end
269 |
270 | def matches_fully?(string, partial_regexp)
271 | string =~ full_regexp(partial_regexp)
272 | end
273 |
274 | def transform_value(world, value)
275 | # Transforms were a feature available in Cucumber 1 and 2.
276 | # They have been kind-of replaced by ParameterTypes, which don't work with generic steps
277 | # like CucumberFactory's.
278 | # https://app.cucumber.pro/projects/cucumber-ruby/documents/branch/master/features/docs/writing_support_code/parameter_types.feature
279 | if world.respond_to?(:Transform)
280 | world.Transform(value)
281 | else
282 | value
283 | end
284 | end
285 |
286 | def attribute_name_from_prose(prose)
287 | prose.downcase.gsub(' ', '_').to_sym
288 | end
289 |
290 | def remember_record_names(world, record, attributes)
291 | rememberable_values = attributes.values.select { |v| v.is_a?(String) || v.is_a?(Integer) }
292 | for value in rememberable_values
293 | set_named_record(world, value.to_s, record)
294 | end
295 | end
296 |
297 | end
298 | end
299 | end
300 |
--------------------------------------------------------------------------------
/media/logo.light.shapes.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
166 |
--------------------------------------------------------------------------------
/media/logo.dark.shapes.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
169 |
--------------------------------------------------------------------------------
/spec/cucumber_factory/steps_spec.rb:
--------------------------------------------------------------------------------
1 | require 'spec_helper'
2 |
3 | TRANSFORMS_SUPPORTED = Gem::Version.new(Cucumber::VERSION) < Gem::Version.new('3.0')
4 |
5 | describe 'steps provided by cucumber_factory' do
6 | before(:each) do
7 | prepare_cucumber_example
8 | end
9 |
10 | context 'FactoryBot' do
11 | it "should create ActiveRecord models by calling #new and #save!" do
12 | movie = Movie.new
13 | Movie.should_receive(:new).with(no_args).and_return(movie)
14 | movie.should_receive(:save!)
15 | invoke_cucumber_step("there is a movie")
16 | end
17 |
18 | it "should create models that have a factory_bot factory by calling #FactoryBot.create(:model_name)" do
19 | FactoryBot.should_receive(:create).with(:job_offer, { :title => "Awesome job" })
20 | invoke_cucumber_step('there is a job offer with the title "Awesome job"')
21 | end
22 |
23 | it "should create model variants that have a factory_bot factory by calling #FactoryBot.create(:variant)" do
24 | FactoryBot.should_receive(:create).with(:job_offer, :tempting_job_offer, { :title => "Awesomafiablyfantasmic job" })
25 | invoke_cucumber_step('there is a job offer (tempting job offer) with the title "Awesomafiablyfantasmic job"')
26 | end
27 |
28 | it "should create model variants that have a factory_bot trait by calling #FactoryBot.create(:factory, :trait1, :trait2)" do
29 | FactoryBot.should_receive(:create).with(:job_offer, :risky, :lucrative, { :title => "Awesomafiablyfantasmic job" })
30 | invoke_cucumber_step('there is a job offer (risky, lucrative) with the title "Awesomafiablyfantasmic job"')
31 | end
32 |
33 | it "should create model variants that have a factory_bot factory by using the model name as a factory name" do
34 | FactoryBot.should_receive(:create).with(:job_offer, { :title => "Awesomafiablyfantasmic job" })
35 | invoke_cucumber_step('there is a job offer with the title "Awesomafiablyfantasmic job"')
36 | end
37 |
38 | it "should instantiate classes with multiple words in their name" do
39 | job_offer = JobOffer.new
40 | JobOffer.should_receive(:new).with(no_args).and_return(job_offer)
41 | invoke_cucumber_step("there is a job offer")
42 | end
43 |
44 | it "should instantiate classes with uppercase characters in their name" do
45 | user = User.new
46 | User.should_receive(:new).and_return(user)
47 | invoke_cucumber_step("there is a User")
48 | end
49 |
50 | it "should allow either 'a' or 'an' for the article" do
51 | opera = Opera.new
52 | Opera.should_receive(:new).with(no_args).and_return(opera)
53 | invoke_cucumber_step("there is an opera")
54 | end
55 |
56 | it "should create records with attributes" do
57 | movie = Movie.new
58 | Movie.stub(:new => movie)
59 | invoke_cucumber_step('there is a movie with the title "Sunshine" and the year "2007"')
60 | movie.title.should == "Sunshine"
61 | movie.year.should == 2007
62 | end
63 |
64 | it "should allow to join attribute lists with 'and's, commas and 'but's" do
65 | movie = Movie.new
66 | Movie.stub(:new => movie)
67 | invoke_cucumber_step('there is a movie with the title "Sunshine", the year "2007" but with the box office result "32000000"')
68 | movie.title.should == "Sunshine"
69 | movie.year.should == 2007
70 | movie.box_office_result.should == 32000000
71 | end
72 |
73 | if TRANSFORMS_SUPPORTED
74 | it "should apply Cucumber transforms to attribute values" do
75 | movie = Movie.new
76 | Movie.stub(:new => movie)
77 | @main.instance_eval do
78 | Transform /^(value)$/ do |value|
79 | 'transformed value'
80 | end
81 | end
82 | invoke_cucumber_step('there is a movie with the title "value"')
83 | movie.title.should == "transformed value"
84 | end
85 | end
86 |
87 | it "should create records with attributes containing spaces" do
88 | movie = Movie.new
89 | Movie.stub(:new => movie)
90 | invoke_cucumber_step('there is a movie with the box office result "99999999"')
91 | movie.box_office_result.should == 99999999
92 | end
93 |
94 | it "should create records with attributes containing uppercase characters" do
95 | user = User.new
96 | User.stub(:new => user)
97 | invoke_cucumber_step('there is a User with the Name "Susanne"')
98 | user.name.should == "Susanne"
99 | end
100 |
101 | it "should override attr_accessible protection" do
102 | invoke_cucumber_step('there is a payment with the amount "120" and the comment "Thanks for lending"')
103 | payment = Payment.last
104 | payment.amount.should == 120
105 | payment.comment.should == 'Thanks for lending'
106 | end
107 |
108 | it "should allow to set an explicit primary key" do
109 | invoke_cucumber_step('there is a payment with the ID 2')
110 | payment = Payment.last
111 | payment.id.should == 2
112 | end
113 |
114 | it "should allow to name records and set a belongs_to association to that record by referring to that name" do
115 | invoke_cucumber_step('"Some Prequel" is a movie with the title "Before Sunrise"')
116 | invoke_cucumber_step('there is a movie with the title "Limitless"')
117 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Some Prequel"')
118 | movie = Movie.find_by_title!('Before Sunset')
119 | prequel = Movie.find_by_title!('Before Sunrise')
120 | movie.prequel.should == prequel
121 | end
122 |
123 | it "should allow to set a belongs_to association to a previously created record by referring to any string attribute of that record" do
124 | invoke_cucumber_step('there is a movie with the title "Before Sunrise"')
125 | invoke_cucumber_step('there is a movie with the title "Limitless"')
126 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Before Sunrise"')
127 | movie = Movie.find_by_title!('Before Sunset')
128 | prequel = Movie.find_by_title!('Before Sunrise')
129 | movie.prequel.should == prequel
130 | end
131 |
132 | it "should allow to set a belongs_to association to a previously updated record by referring to any string attribute used when updating" do
133 | invoke_cucumber_step('there is a movie')
134 | invoke_cucumber_step('the movie above has the title "Before Sunrise"')
135 | invoke_cucumber_step('there is a movie with the title "Limitless"')
136 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Before Sunrise"')
137 | movie = Movie.find_by_title!('Before Sunset')
138 | prequel = Movie.find_by_title!('Before Sunrise')
139 | movie.prequel.should == prequel
140 | end
141 |
142 | it "should allow to set a belongs_to association to a previously created record by referring to their explicitely set primary keys" do
143 | invoke_cucumber_step('there is a movie with the ID 123')
144 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel 123')
145 | movie = Movie.find_by_title!('Before Sunset')
146 | prequel = Movie.find(123)
147 | movie.prequel.should == prequel
148 | end
149 |
150 | it "should allow to set a belongs_to association to a previously created record by saying 'above'" do
151 | invoke_cucumber_step('there is a user with the name "Jane"')
152 | invoke_cucumber_step('there is a user with the name "John"')
153 | invoke_cucumber_step('there is a movie with the title "Limitless"')
154 | invoke_cucumber_step('there is a movie with the title "Before Sunrise"')
155 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above and the prequel above')
156 | before_sunset = Movie.find_by_title!("Before Sunset")
157 | before_sunset.prequel.title.should == "Before Sunrise"
158 | before_sunset.reviewer.name.should == "John"
159 | end
160 |
161 | if TRANSFORMS_SUPPORTED
162 | it "should fallback to using transforms when no named record is found" do
163 | user = User.create!(:name => 'Me')
164 | @main.instance_eval do
165 | Transform(/^(me)$/) do |value|
166 | user
167 | end
168 | end
169 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer "me"')
170 | before_sunset = Movie.find_by_title!("Before Sunset")
171 | before_sunset.reviewer.should == user
172 | end
173 | end
174 |
175 | it "should give created_at precedence over id when saying 'above' if the primary key is not numeric" do
176 | invoke_cucumber_step('there is a uuid user with the name "Jane" and the id "jane"')
177 | invoke_cucumber_step('there is a uuid user with the name "John" and the id "john"')
178 |
179 | uuid_user = UuidUser.find_by_name("John")
180 | ActiveRecord::VERSION::MAJOR >= 6 ? uuid_user.update!(:created_at => 1.day.ago) : uuid_user.update_attributes!(:created_at => 1.day.ago)
181 |
182 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the uuid reviewer above')
183 | before_sunset = Movie.find_by_title!("Before Sunset")
184 | before_sunset.uuid_reviewer.name.should == "Jane"
185 | end
186 |
187 | it "should ignore created_at if the primary key is numeric" do
188 | invoke_cucumber_step('there is a user with the name "Jane"')
189 | invoke_cucumber_step('there is a user with the name "John"')
190 |
191 | user = User.find_by_name("John")
192 | ActiveRecord::VERSION::MAJOR >= 6 ? user.update!(:created_at => 1.day.ago) : user.update_attributes!(:created_at => 1.day.ago)
193 |
194 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above')
195 | before_sunset = Movie.find_by_title!("Before Sunset")
196 | before_sunset.reviewer.name.should == "John"
197 | end
198 |
199 | it "should raise a proper error if there is no previous record when saying 'above'" do
200 | lambda do
201 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer above and the prequel above')
202 | end.should raise_error(/There is no last reviewer/i)
203 | end
204 |
205 | it "should reload an object assigned to a belongs_to before assigning" do
206 | invoke_cucumber_step('"Jane" is a user who is deleted')
207 |
208 | user = User.last
209 | ActiveRecord::VERSION::MAJOR >= 6 ? user.update!(:deleted => false) : user.update_attributes!(:deleted => false)
210 |
211 | proc { invoke_cucumber_step('there is a movie with the title "Before Sunset" and the reviewer "Jane"') }.should_not raise_error
212 | end
213 |
214 | it "should allow to set positive boolean attributes with 'who' after the attribute list" do
215 | user = User.new
216 | User.stub(:new => user)
217 | invoke_cucumber_step('there is a user with the name "Jane" who is deleted')
218 | user.name.should == "Jane"
219 | user.deleted.should == true
220 | end
221 |
222 | it "should allow to name records and set a belongs_to association to that record by referring to that name" do
223 | invoke_cucumber_step('"Some Prequel" is a movie with the title "Before Sunrise"')
224 | invoke_cucumber_step('there is a movie with the title "Limitless"')
225 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Some Prequel"')
226 | movie = Movie.find_by_title!('Before Sunset')
227 | prequel = Movie.find_by_title!('Before Sunrise')
228 | movie.prequel.should == prequel
229 | end
230 |
231 | it "should allow to set positive boolean attributes with 'which' after the attribute list" do
232 | user = User.new
233 | User.stub(:new => user)
234 | invoke_cucumber_step('there is a user with the name "Jane" which is deleted')
235 | user.name.should == "Jane"
236 | user.deleted.should == true
237 | end
238 |
239 | it "should allow to set positive boolean attributes with 'that' after the attribute list" do
240 | user = User.new
241 | User.stub(:new => user)
242 | invoke_cucumber_step('there is a user with the name "Jane" that is deleted')
243 | user.name.should == "Jane"
244 | user.deleted.should == true
245 | end
246 |
247 | it "should allow to set boolean attributes without regular attributes preceding them" do
248 | user = User.new
249 | User.stub(:new => user)
250 | invoke_cucumber_step('there is a user who is deleted')
251 | user.deleted.should == true
252 | end
253 |
254 | it "should allow to set negative boolean attribute" do
255 | user = User.new
256 | User.stub(:new => user)
257 | invoke_cucumber_step('there is a user who is not deleted')
258 | user.deleted.should == false
259 | end
260 |
261 | it "should allow to set multiple boolean attributes" do
262 | user = User.new
263 | User.stub(:new => user)
264 | invoke_cucumber_step('there is a user who is locked and not deleted and subscribed')
265 | user.locked.should == true
266 | user.deleted.should == false
267 | user.subscribed.should == true
268 | end
269 |
270 | it "should allow to set boolean attributes that are named from multiple words" do
271 | user = User.new
272 | User.stub(:new => user)
273 | invoke_cucumber_step('there is a user who is locked and not scared and scared by spiders and deleted')
274 | user.locked.should == true
275 | user.scared.should == false
276 | user.scared_by_spiders.should == true
277 | user.deleted.should == true
278 | end
279 |
280 | it "should allow to join boolean attribute lists with 'and's, commas and 'but's" do
281 | user = User.new
282 | User.stub(:new => user)
283 | invoke_cucumber_step('there is a user who is locked, scared, but scared by spiders and deleted')
284 | user.locked.should == true
285 | user.scared.should == true
286 | user.scared_by_spiders.should == true
287 | user.deleted.should == true
288 | end
289 |
290 | it "should allow to set a has_many association by referring to multiple named records in square brackets" do
291 | invoke_cucumber_step('there is a movie with the title "Sunshine"')
292 | invoke_cucumber_step('there is a movie with the title "Limitless"')
293 | invoke_cucumber_step('there is a user with the reviewed movies ["Sunshine" and "Limitless"]')
294 | user = User.last
295 | reviewed_movie_titles = user.reviewed_movies.map(&:title)
296 | reviewed_movie_titles.should =~ ['Sunshine', 'Limitless']
297 | end
298 |
299 | it 'allow associations for transient attributes if they are named after the associated model' do
300 | invoke_cucumber_step('there is a movie with the title "Sunshine"')
301 | invoke_cucumber_step('there is a user with the movie "Sunshine"')
302 | user = User.last
303 | user.reviewed_movies.count.should == 1
304 | user.reviewed_movies.first.title.should == 'Sunshine'
305 | end
306 |
307 | it 'allow associations for transient attributes if they are named like a factory' do
308 | invoke_cucumber_step('there is a movie with the title "Sunshine"')
309 | invoke_cucumber_step('there is a user with the film "Sunshine"')
310 | user = User.last
311 | user.reviewed_movies.count.should == 1
312 | user.reviewed_movies.first.title.should == 'Sunshine'
313 | end
314 |
315 | it "should allow to set attributes via doc string" do
316 | user = User.new
317 | User.stub(:new => user)
318 |
319 | invoke_cucumber_step('there is a user with these attributes:', <<-DOC_STRING)
320 | name: Jane
321 | locked: true
322 | DOC_STRING
323 |
324 | user.name.should == "Jane"
325 | user.locked.should == true
326 | end
327 |
328 | it "should allow to set attributes via additional doc string" do
329 | user = User.new
330 | User.stub(:new => user)
331 |
332 | invoke_cucumber_step('there is a user with the email "test@invalid.com" and these attributes:', <<-DOC_STRING)
333 | name: Jane
334 | DOC_STRING
335 |
336 | user.name.should == "Jane"
337 | user.email.should == "test@invalid.com"
338 | end
339 |
340 | it 'should allow named records when setting attributes via doc string' do
341 | invoke_cucumber_step('"Some Prequel" is a movie with these attributes:', <<-DOC_STRING)
342 | title: Before Sunrise
343 | DOC_STRING
344 | invoke_cucumber_step('there is a movie with the title "Limitless"')
345 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Some Prequel"')
346 | movie = Movie.find_by_title!('Before Sunset')
347 | prequel = Movie.find_by_title!('Before Sunrise')
348 | movie.prequel.should == prequel
349 | end
350 |
351 | it "should allow to set attributes via data table" do
352 | user = User.new
353 | User.stub(:new => user)
354 |
355 | invoke_cucumber_step('there is a user with these attributes:', nil, <<-DATA_TABLE)
356 | | name | Jane |
357 | | locked | true |
358 | DATA_TABLE
359 |
360 | user.name.should == "Jane"
361 | user.locked.should == true
362 | end
363 |
364 | it "should allow to set attributes via additional data table" do
365 | user = User.new
366 | User.stub(:new => user)
367 |
368 | invoke_cucumber_step('there is a user with the email "test@invalid.com" and these attributes:', nil, <<-DATA_TABLE)
369 | | name | Jane |
370 | DATA_TABLE
371 |
372 | user.name.should == "Jane"
373 | user.email.should == "test@invalid.com"
374 | end
375 |
376 | it 'should allow named records when setting attributes via data table' do
377 | invoke_cucumber_step('"Some Prequel" is a movie with these attributes:', nil, <<-DATA_TABLE)
378 | | title | Before Sunrise |
379 | DATA_TABLE
380 | invoke_cucumber_step('there is a movie with the title "Limitless"')
381 | invoke_cucumber_step('there is a movie with the title "Before Sunset" and the prequel "Some Prequel"')
382 | movie = Movie.find_by_title!('Before Sunset')
383 | prequel = Movie.find_by_title!('Before Sunrise')
384 | movie.prequel.should == prequel
385 | end
386 |
387 | it "should allow mixed single quotes for model names" do
388 | invoke_cucumber_step("'Some Prequel' is a movie with the title \"Before Sunrise\"")
389 | invoke_cucumber_step('there is a movie with the title "Limitless"')
390 | invoke_cucumber_step('there is a movie with the title \'Before Sunset\' and the prequel "Some Prequel"')
391 | movie = Movie.find_by_title!('Before Sunset')
392 | prequel = Movie.find_by_title!('Before Sunrise')
393 | movie.prequel.should == prequel
394 | end
395 |
396 | it 'supports named associations with polymorphic associations' do
397 | invoke_cucumber_step('"my opera" is an opera')
398 | invoke_cucumber_step('there is a movie with the premiere site "my opera"')
399 | end
400 |
401 | it 'does not support last record references with polymorphic associations as the target class cannot be guessed' do
402 | invoke_cucumber_step('there is an opera')
403 | expect {
404 | invoke_cucumber_step('there is a movie with the premiere site above')
405 | }.to raise_error(CucumberFactory::Factory::Error, 'Cannot set last Movie#premiere_site for polymorphic associations')
406 | end
407 |
408 | it 'supports carrierwave uploaders' do
409 | invoke_cucumber_step('there is a payment with the attachment file:"spec/assets/file.txt"')
410 | payment = Payment.last
411 | expect(payment.attachment.file.read).to eq "This is a test file.\n"
412 | end
413 |
414 | it 'supports single quote for carrierwave uploaders' do
415 | invoke_cucumber_step("there is a payment with the attachment file:'spec/assets/file.txt'")
416 | payment = Payment.last
417 | expect(payment.attachment.file.read).to eq "This is a test file.\n"
418 | end
419 |
420 | it 'is able to read symlinked files' do
421 | invoke_cucumber_step("there is a payment with the attachment file:'spec/assets/symlink.txt'")
422 | payment = Payment.last
423 | expect(payment.attachment.file.read).to eq "This is a test file.\n"
424 | end
425 |
426 | it 'supports table syntax for carrierwave uploaders' do
427 | invoke_cucumber_step('there is a payment with these attributes:', nil, <<-DATA_TABLE)
428 | | attachment | file:"spec/assets/file.txt" |
429 | DATA_TABLE
430 | payment = Payment.last
431 | expect(payment.attachment.file.read).to eq "This is a test file.\n"
432 | end
433 |
434 | it 'supports doc string syntax for carrierwave uploaders' do
435 | invoke_cucumber_step('there is a payment with these attributes:', <<-DOC_STRING)
436 | attachment: file:"spec/assets/file.txt"
437 | DOC_STRING
438 | payment = Payment.last
439 | payment.save!
440 | expect(payment.attachment.file.read).to eq "This is a test file.\n"
441 | end
442 |
443 | it 'allows updating a carrierwave attribute' do
444 | invoke_cucumber_step('there is a payment with the attachment file:"spec/assets/file.txt"')
445 | payment = Payment.last
446 | expect(payment.attachment.file.read).to eq "This is a test file.\n"
447 | invoke_cucumber_step('the payment above has the attachment file:"spec/assets/file2.txt"')
448 | payment.reload
449 | expect(payment.attachment.file.read).to eq "This is the second test file.\n"
450 | end
451 |
452 | it 'works with nested factories (BUGFIX)' do
453 | invoke_cucumber_step('there is a subgenre movie')
454 | end
455 |
456 | describe 'references to named records are tracked correctly' do
457 | # CucumberFactory keeps track of all created records by their attributes.
458 | # For example, if you create a user with the name "Peter" you can reference him later on as "Peter".
459 |
460 | it 'does not overwrite existing references when associating new records with another reference (BUGFIX)' do
461 | invoke_cucumber_step('"reviewer" is a user with the id "1"')
462 | movie1 = invoke_cucumber_step('there is a movie with the reviewer "reviewer" and the id "2"') # <- should not overwrite the 'reviewer' reference
463 | movie2 = invoke_cucumber_step('there is a movie with the reviewer "reviewer" and the id "3"')
464 |
465 | expect(movie1.reviewer_id).to eq(1)
466 | expect(movie2.reviewer_id).to eq(1)
467 | end
468 |
469 | it 'does not set new references when setting primary keys of an association (BUGFIX)' do
470 | movie1 = invoke_cucumber_step('there is a movie with the id "123" and the user id "456"') # <- should not set a '456' reference
471 | movie2 = invoke_cucumber_step('there is a movie with the user id "456"')
472 |
473 | expect(movie1.reviewer_id).to eq(456)
474 | expect(movie2.reviewer_id).to eq(456)
475 | end
476 | end
477 | end
478 |
479 | context 'without FactoryBot' do
480 | before do
481 | hide_const("FactoryBot")
482 | end
483 |
484 | it "should instantiate plain ruby classes by calling #new" do
485 | PlainRubyClass.should_receive(:new).with({})
486 | invoke_cucumber_step("there is a plain ruby class")
487 | end
488 |
489 | it "should instantiate namespaced classes" do
490 | actor = People::Actor.new
491 | People::Actor.should_receive(:new).and_return(actor)
492 | invoke_cucumber_step("there is a people/actor")
493 | end
494 |
495 | it "should allow to set integer attributes without surrounding quotes" do
496 | invoke_cucumber_step('there is a plain Ruby class with the amount 123 and the total 456')
497 | obj = PlainRubyClass.last
498 | obj.attributes[:amount].should == 123
499 | obj.attributes[:total].should == 456
500 | end
501 |
502 | it "should allow to set decimal attributes without surrounding quotes" do
503 | invoke_cucumber_step('there is a plain Ruby class with the amount 1.23 and the total 45.6')
504 | obj = PlainRubyClass.last
505 | obj.attributes[:amount].should be_a(BigDecimal)
506 | obj.attributes[:amount].to_s.should == "1.23"
507 | obj.attributes[:total].should be_a(BigDecimal)
508 | obj.attributes[:total].to_s.should == "45.6"
509 | end
510 |
511 | it "should allow to set file attributes with the file:'path' syntax" do
512 | invoke_cucumber_step('there is a plain Ruby class with the file file:"spec/assets/file.txt"')
513 | obj = PlainRubyClass.last
514 | obj.attributes[:file].should be_a(File)
515 | obj.attributes[:file].read.should == "This is a test file.\n"
516 | end
517 |
518 | it "should allow set an array of strings with square brackets" do
519 | invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar"] and the list ["bam", "baz"]')
520 | obj = PlainRubyClass.last
521 | obj.attributes[:tags].should == ['foo', 'bar']
522 | obj.attributes[:list].should == ['bam', 'baz']
523 | end
524 |
525 | it "should allow set an array of numbers with square brackets" do
526 | invoke_cucumber_step('there is a plain Ruby class with the integers [1, 2] and the decimals [3.4, 4.5]')
527 | obj = PlainRubyClass.last
528 | obj.attributes[:integers].should == [1, 2]
529 | obj.attributes[:decimals].should == [BigDecimal('3.4'), BigDecimal('4.5')]
530 | end
531 |
532 | it 'should allow to set an empty array' do
533 | invoke_cucumber_step('there is a plain Ruby class with the tags []')
534 | obj = PlainRubyClass.last
535 | obj.attributes[:tags].should == []
536 | end
537 |
538 | it 'should allow to separate array values with either a comma or "and"' do
539 | invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar" and "baz"] and the list ["bam", "baz" and "qux"]')
540 | obj = PlainRubyClass.last
541 | obj.attributes[:tags].should == ['foo', 'bar', 'baz']
542 | obj.attributes[:list].should == ['bam', 'baz', 'qux']
543 | end
544 |
545 | it 'should allow to separate array values with an Oxford comma' do
546 | invoke_cucumber_step('there is a plain Ruby class with the tags ["foo", "bar", and "baz"] and the list ["bam", "baz", and "qux"]')
547 | obj = PlainRubyClass.last
548 | obj.attributes[:tags].should == ['foo', 'bar', 'baz']
549 | obj.attributes[:list].should == ['bam', 'baz', 'qux']
550 | end
551 |
552 | it "should allow attribute names starting with 'the'" do
553 | PlainRubyClass.should_receive(:new).with({:theme => 'Sci-fi'})
554 | invoke_cucumber_step('there is a plain ruby class with the theme "Sci-fi"')
555 | end
556 |
557 | it "should allow attribute names starting with 'and'" do
558 | PlainRubyClass.should_receive(:new).with({:android => 'Paranoid'})
559 | invoke_cucumber_step('there is a plain ruby class with the android "Paranoid"')
560 | end
561 |
562 | it "should allow attribute names starting with 'with'" do
563 | PlainRubyClass.should_receive(:new).with({:withdrawal => 'bank_account'})
564 | invoke_cucumber_step('there is a plain ruby class with the withdrawal "bank_account"')
565 | end
566 |
567 | it "should allow attribute names starting with 'but'" do
568 | PlainRubyClass.should_receive(:new).with({:butt => 'pear-shaped'})
569 | invoke_cucumber_step('there is a plain ruby class with the butt "pear-shaped"')
570 | end
571 |
572 | it "should allow to set array attributes via doc string" do
573 | invoke_cucumber_step('there is a plain Ruby class with these attributes:', <<-DOC_STRING)
574 | tags: ["foo", "bar"]
575 | DOC_STRING
576 |
577 | obj = PlainRubyClass.last
578 | obj.attributes[:tags].should == ['foo', 'bar']
579 | end
580 |
581 | it "should allow to set array attributes via data table" do
582 | invoke_cucumber_step('there is a plain Ruby class with these attributes:', nil, <<-DATA_TABLE)
583 | | tags | ["foo", "bar"] |
584 | DATA_TABLE
585 |
586 | obj = PlainRubyClass.last
587 | obj.attributes[:tags].should == ['foo', 'bar']
588 | end
589 |
590 | it "should create models that have a machinist blueprint by calling #make" do
591 | MachinistModel.should_receive(:make).with({ :attribute => "foo"})
592 | invoke_cucumber_step('there is a machinist model with the attribute "foo"')
593 | end
594 |
595 | it "should be able to step_match machinist blueprint variants" do
596 | MachinistModel.should_receive(:make).with(:variant, { :attribute => "foo"})
597 | invoke_cucumber_step('there is a machinist model (variant) with the attribute "foo"')
598 | end
599 |
600 | it "should be able to step_match machinist blueprint variants containing spaces or uppercase characters in prose" do
601 | MachinistModel.should_receive(:make).with(:variant_mark_two, { :attribute => "foo"})
602 | invoke_cucumber_step('there is a machinist model (Variant Mark Two) with the attribute "foo"')
603 | end
604 |
605 | it "should allow single quote for attribute values" do
606 | MachinistModel.should_receive(:make).with({ :attribute => "foo"})
607 | invoke_cucumber_step("there is a machinist model with the attribute 'foo'")
608 | end
609 |
610 | it "should allow mixed single and double quotes for different attribute values" do
611 | MachinistModel.should_receive(:make).with({ :attribute => "foo", :other_attribute => "bar" })
612 | invoke_cucumber_step("there is a machinist model with the attribute 'foo' and the other attribute \"bar\"")
613 | end
614 |
615 | it 'should not raise an error for a blank instance name' do
616 | MachinistModel.should_receive(:make).with({ :attribute => 'foo' })
617 | invoke_cucumber_step("'' is a machinist model with the attribute 'foo'")
618 | end
619 |
620 | it 'should warn if there are unused fragments' do
621 | MachinistModel.should_not_receive(:make)
622 | lambda { invoke_cucumber_step("there is a machinist model with the attribute NOQUOTES") }.should raise_error(ArgumentError, 'Unable to parse attributes " with the attribute NOQUOTES".')
623 | lambda { invoke_cucumber_step("there is a machinist model with the attribute 'foo' and the ") }.should raise_error(ArgumentError, 'Unable to parse attributes " and the ".')
624 | lambda { invoke_cucumber_step("there is a machinist model with the attribute 'foo'. the other_attribute 'bar' and the third attribute 'baz'") }.should raise_error(ArgumentError, 'Unable to parse attributes ".".')
625 | end
626 |
627 | it "should allow to update the last record of a type" do
628 | invoke_cucumber_step('there is a user with the name "Bar" and the email "foo@example.com" who is not subscribed')
629 | invoke_cucumber_step('the user above has the name "Baz", the email "foobar@example.com", and is subscribed')
630 | user = User.last
631 | user.name.should == 'Baz'
632 | user.email.should == 'foobar@example.com'
633 | user.subscribed.should == true
634 | end
635 |
636 | it "should be able to update a record with a given name" do
637 | invoke_cucumber_step('"Foo" is a user with the name "Bar"')
638 | invoke_cucumber_step('the user "Foo" has the email "foo@example.com"')
639 | invoke_cucumber_step("the user 'Foo' is subscribed")
640 | user = User.last
641 | user.name.should == 'Bar'
642 | user.email.should == 'foo@example.com'
643 | user.subscribed.should == true
644 | end
645 |
646 | it "should be able to update a record with a Cucumber table expression" do
647 | invoke_cucumber_step('"Foo" is a user with the name "Bar"')
648 | invoke_cucumber_step('the user above has these attributes:', nil, <<-DATA_TABLE)
649 | | name | Jane |
650 | | locked | true |
651 | DATA_TABLE
652 | user = User.last
653 | user.name.should == "Jane"
654 | user.locked.should == true
655 | end
656 |
657 | it "should allow to update a record via additional data table" do
658 | invoke_cucumber_step('"Foo" is a user with the name "Bar"')
659 | invoke_cucumber_step('the user above has the email "test@invalid.com", is subscribed, and has these attributes:', nil, <<-DATA_TABLE)
660 | | name | Jane |
661 | DATA_TABLE
662 | user = User.last
663 | user.name.should == "Jane"
664 | user.email.should == "test@invalid.com"
665 | user.subscribed.should == true
666 | end
667 |
668 | it "should allow to update an association" do
669 | invoke_cucumber_step('there is a movie with the title "Before Sunrise"')
670 | invoke_cucumber_step('there is a user with the name "John"')
671 | invoke_cucumber_step('the movie above has the reviewer above')
672 | movie = Movie.last
673 | movie.reviewer.name.should == "John"
674 | end
675 | end
676 | end
677 |
--------------------------------------------------------------------------------
7 | 
14 |