cucumber_factory 2.1.0 → 2.4.0

data/Gemfile.cucumber-5.3

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+# Runtime dependencies
+gem 'cucumber', '~> 5.3.0'
+gem 'activesupport', '~> 6.1.0'
+gem 'activerecord', '~> 6.1.0'
+gem 'pg'
+
+# Development dependencies
+gem 'rspec', '~> 3.0'
+gem 'rake'
+gem 'database_cleaner'
+gem 'gemika'
+
+# Test dependencies
+gem 'factory_bot'
+gem 'carrierwave'
+
+# Gem under test
+gem 'cucumber_factory', :path => '.'

data/Gemfile.cucumber-5.3.lock

@@ -0,0 +1,140 @@
+PATH
+  remote: .
+  specs:
+    cucumber_factory (2.4.0)
+      activerecord
+      activesupport
+      cucumber
+      cucumber_priority (>= 0.2.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.1.3.1)
+      activesupport (= 6.1.3.1)
+    activerecord (6.1.3.1)
+      activemodel (= 6.1.3.1)
+      activesupport (= 6.1.3.1)
+    activesupport (6.1.3.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    addressable (2.7.0)
+      public_suffix (>= 2.0.2, < 5.0)
+    builder (3.2.4)
+    carrierwave (2.2.1)
+      activemodel (>= 5.0.0)
+      activesupport (>= 5.0.0)
+      addressable (~> 2.6)
+      image_processing (~> 1.1)
+      marcel (~> 1.0.0)
+      mini_mime (>= 0.1.3)
+      ssrf_filter (~> 1.0)
+    concurrent-ruby (1.1.8)
+    cucumber (5.3.0)
+      builder (~> 3.2, >= 3.2.4)
+      cucumber-core (~> 8.0, >= 8.0.1)
+      cucumber-create-meta (~> 2.0, >= 2.0.2)
+      cucumber-cucumber-expressions (~> 10.3, >= 10.3.0)
+      cucumber-gherkin (~> 15.0, >= 15.0.2)
+      cucumber-html-formatter (~> 9.0, >= 9.0.0)
+      cucumber-messages (~> 13.1, >= 13.1.0)
+      cucumber-wire (~> 4.0, >= 4.0.1)
+      diff-lcs (~> 1.4, >= 1.4.4)
+      multi_test (~> 0.1, >= 0.1.2)
+      sys-uname (~> 1.2, >= 1.2.1)
+    cucumber-core (8.0.1)
+      cucumber-gherkin (~> 15.0, >= 15.0.2)
+      cucumber-messages (~> 13.0, >= 13.0.1)
+      cucumber-tag-expressions (~> 2.0, >= 2.0.4)
+    cucumber-create-meta (2.0.4)
+      cucumber-messages (~> 13.1, >= 13.1.0)
+      sys-uname (~> 1.2, >= 1.2.1)
+    cucumber-cucumber-expressions (10.3.0)
+    cucumber-gherkin (15.0.2)
+      cucumber-messages (~> 13.0, >= 13.0.1)
+    cucumber-html-formatter (9.0.0)
+      cucumber-messages (~> 13.0, >= 13.0.1)
+    cucumber-messages (13.2.1)
+      protobuf-cucumber (~> 3.10, >= 3.10.8)
+    cucumber-tag-expressions (2.0.4)
+    cucumber-wire (4.0.1)
+      cucumber-core (~> 8.0, >= 8.0.1)
+      cucumber-cucumber-expressions (~> 10.3, >= 10.3.0)
+      cucumber-messages (~> 13.0, >= 13.0.1)
+    cucumber_priority (0.3.2)
+      cucumber
+    database_cleaner (2.0.1)
+      database_cleaner-active_record (~> 2.0.0)
+    database_cleaner-active_record (2.0.0)
+      activerecord (>= 5.a)
+      database_cleaner-core (~> 2.0.0)
+    database_cleaner-core (2.0.1)
+    diff-lcs (1.4.4)
+    factory_bot (6.1.0)
+      activesupport (>= 5.0.0)
+    ffi (1.15.0)
+    gemika (0.5.0)
+    i18n (1.8.9)
+      concurrent-ruby (~> 1.0)
+    image_processing (1.12.1)
+      mini_magick (>= 4.9.5, < 5)
+      ruby-vips (>= 2.0.17, < 3)
+    marcel (1.0.0)
+    middleware (0.1.0)
+    mini_magick (4.11.0)
+    mini_mime (1.0.3)
+    minitest (5.14.4)
+    multi_test (0.1.2)
+    pg (1.2.3)
+    protobuf-cucumber (3.10.8)
+      activesupport (>= 3.2)
+      middleware
+      thor
+      thread_safe
+    public_suffix (4.0.6)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.2)
+    ruby-vips (2.1.0)
+      ffi (~> 1.12)
+    ssrf_filter (1.0.7)
+    sys-uname (1.2.2)
+      ffi (~> 1.1)
+    thor (1.1.0)
+    thread_safe (0.3.6)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 6.1.0)
+  activesupport (~> 6.1.0)
+  carrierwave
+  cucumber (~> 5.3.0)
+  cucumber_factory!
+  database_cleaner
+  factory_bot
+  gemika
+  pg
+  rake
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -1,4 +1,4 @@
-cucumber_factory [![Build Status](https://travis-ci.org/makandra/cucumber_factory.svg?branch=master)](https://travis-ci.org/makandra/cucumber_factory)
+cucumber_factory [![Tests](https://github.com/makandra/cucumber_factory/workflows/Tests/badge.svg)](https://github.com/makandra/cucumber_factory/actions?query=branch:master)
 ================
 
 Create ActiveRecord objects without step definitions
@@ -24,6 +24,13 @@ Quoted strings and numbers denote attribute values:
 Given there is a movie with the title "Sunshine" and the year 2007
 ```
 
+To update an existing record, specify the record and the changes:
+```
+Given the movie above has the title "Sunset" and the year 2008
+Given the movie "Sunrise" has the year 2009
+```
+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.
+
 Setting boolean attributes
 --------------------------
 
@@ -42,6 +49,13 @@ Given there is a movie which is awesome, popular and successful but not science
 And there is a director with the income "500000" but with the account balance "-30000"
 ```
 
+To update boolean attributes use the keyword `is`:
+
+```cucumber
+Given the movie above is awesome but not popular
+Given the movie above has the year 1979 but is not science fiction
+```
+
 
 Setting many attributes with a table
 ------------------------------------
@@ -62,6 +76,14 @@ Given there is a movie with these attributes:
   | comedy | false    |
 ```
 
+```cucumber
+Given the movie above has these attributes:
+  """
+  name: Sunshine
+  comedy: false
+  """
+```
+
 Setting associations
 --------------------
 
@@ -129,7 +151,16 @@ Given there is a movie with the tags ["comedy", "drama" and "action"]
 ```
 
 
+Setting file attributes
+-----------------------
+
+You can set an attribute to a file object with the following syntax:
+
+```cucumber
+Given there is a movie with the image file:'path/to/image.jpg'
+```
 
+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.
 
 Using named factories and traits
 --------------------------------
@@ -191,23 +222,22 @@ Development
 There are tests in `spec`. We only accept PRs with tests. To run tests:
 
 - Install the Ruby version stated in `.ruby-version`
-- Create a local MySQL/MariaDB database named `cucumber_factory_test`
+- Create a local PostgreSQL database:
 ```
-$ mysql -u root -p
-> create database cucumber_factory_test;
+$ sudo -u postgres psql -c 'create database cucumber_factory_test;'
 ```
 
 - Copy `spec/support/database.sample.yml` to `spec/support/database.yml` and enter your local credentials for the test databases
 - Install development dependencies using `bundle install`
 - Run tests with the default symlinked Gemfile using `bundle exec rspec` or explicit with `BUNDLE_GEMFILE=Gemfile.cucumber-x.x bundle exec rspec spec`
 
-We recommend to test large changes against multiple versions of Ruby and multiple dependency sets. Supported combinations are configured in `.travis.yml`. We provide some rake tasks to help with this:
+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:
 
 For each ruby version do (you need to change it manually):
 - Install development dependencies using `rake matrix:install`
 - Run tests using `rake matrix:spec`
 
-Note that we have configured Travis CI to automatically run tests in all supported Ruby versions and dependency sets after each push. We will only merge pull requests after a green Travis build.
+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.
 
 If you would like to contribute:
 

data/lib/cucumber_factory.rb

@@ -13,6 +13,7 @@ require 'cucumber_priority'
 
 # Gem
 require 'cucumber_factory/build_strategy'
+require 'cucumber_factory/update_strategy'
 require 'cucumber_factory/factory'
 require 'cucumber_factory/switcher'
 

data/lib/cucumber_factory/build_strategy.rb

@@ -11,6 +11,7 @@ module CucumberFactory
         factory = factory_bot_factory(model_prose, variants)
 
         if factory
+          factory.compile # Required to load inherited traits!
           strategy = factory_bot_strategy(factory, model_prose, variants)
           transient_attributes = factory_bot_transient_attributes(factory, variants)
         else
@@ -21,6 +22,10 @@ module CucumberFactory
         [strategy, transient_attributes]
       end
 
+      def parse_model_class(model_prose)
+        underscored_model_name(model_prose).camelize.constantize
+      end
+
       private
 
       def variants_from_prose(variant_prose)
@@ -84,7 +89,7 @@ module CucumberFactory
       end
 
       def alternative_strategy(model_prose, variants)
-        model_class = underscored_model_name(model_prose).camelize.constantize
+        model_class = parse_model_class(model_prose)
         machinist_strategy(model_class, variants) ||
           active_record_strategy(model_class) ||
           ruby_object_strategy(model_class)

data/lib/cucumber_factory/factory.rb

@@ -2,21 +2,25 @@ module CucumberFactory
   module Factory
     class Error < StandardError; end
 
-    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?'
+    ATTRIBUTES_PATTERN = '( with the .+?)?( (?:which|who|that) is .+?)?' # ... with the year 1979 which is science fiction
     TEXT_ATTRIBUTES_PATTERN = ' (?:with|and) these attributes:'
+    UPDATE_ATTR_PATTERN = '(?: (?:has|belongs to)( the .+?)|(?: and| but|,)*( is .+?))' # ... belongs to the collection "Fantasy" and is trending
+    TEXT_UPDATE_ATTR_PATTERN = '(?: and|,)* has these attributes:'
 
-    RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?'
-    NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?'
+    RECORD_PATTERN = 'there is an? (.+?)( \(.+?\))?' # Given there is a movie (comedy)
+    NAMED_RECORD_PATTERN = '(?:"([^\"]*)"|\'([^\']*)\') is an? (.+?)( \(.+?\))?' # Given "LotR" is a movie
+    RECORD_UPDATE_PATTERN = 'the ([^"\',]+?) (above|".+?"|\'.+?\')' # Given the movie "LotR" ...
 
     NAMED_RECORDS_VARIABLE = :'@named_cucumber_factory_records'
 
     VALUE_INTEGER = /\d+/
     VALUE_DECIMAL = /[\d\.]+/
     VALUE_STRING = /"[^"]*"|'[^']*'/
+    VALUE_FILE = /file:#{VALUE_STRING}/
     VALUE_ARRAY = /\[[^\]]*\]/
     VALUE_LAST_RECORD = /\babove\b/
 
-    VALUE_SCALAR = /#{VALUE_STRING}|#{VALUE_DECIMAL}|#{VALUE_INTEGER}/
+    VALUE_SCALAR = /#{VALUE_STRING}|#{VALUE_DECIMAL}|#{VALUE_INTEGER}|#{VALUE_FILE}/
 
     CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR = {
       :kind => :Before,
@@ -39,6 +43,12 @@ module CucumberFactory
       :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_creation, self, a1, a2, a3, a4) }
     }
 
+    UPDATE_STEP_DESCRIPTOR = {
+      :kind => :And,
+      :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}+$/,
+      :block => lambda { |a1, a2, a3, a4| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4) }
+    }
+
     NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
       :kind => :Given,
       :pattern => /^#{NAMED_RECORD_PATTERN}#{ATTRIBUTES_PATTERN}#{TEXT_ATTRIBUTES_PATTERN}?$/,
@@ -53,6 +63,13 @@ module CucumberFactory
       :priority => true
     }
 
+    UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES = {
+      :kind => :And,
+      :pattern => /^#{RECORD_UPDATE_PATTERN}#{UPDATE_ATTR_PATTERN}*#{TEXT_UPDATE_ATTR_PATTERN}$/,
+      :block => lambda { |a1, a2, a3, a4, a5| CucumberFactory::Factory.send(:parse_update, self, a1, a2, a3, a4, a5) },
+      :priority => true
+    }
+
     class << self
 
       def add_steps(main)
@@ -61,6 +78,8 @@ module CucumberFactory
         add_step(main, CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
         add_step(main, NAMED_CREATION_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
         add_step(main, CLEAR_NAMED_RECORDS_STEP_DESCRIPTOR)
+        add_step(main, UPDATE_STEP_DESCRIPTOR)
+        add_step(main, UPDATE_STEP_DESCRIPTOR_WITH_TEXT_ATTRIBUTES)
       end
 
       private
@@ -69,7 +88,8 @@ module CucumberFactory
         main.instance_eval {
           kind = descriptor[:kind]
           object = send(kind, *[descriptor[:pattern]].compact, &descriptor[:block])
-          object.overridable(:priority => descriptor[:priority] ? 1 : 0) if kind != :Before
+          # cucumber_factory steps get a low priority due to their generic syntax
+          object.overridable(:priority => descriptor[:priority] ? -1 : -2) if kind != :Before
           object
         }
       end
@@ -100,8 +120,24 @@ module CucumberFactory
       end
 
       def parse_creation(world, raw_model, raw_variant, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
-        build_strategy, transient_attributes = BuildStrategy.from_prose(raw_model, raw_variant)
+        build_strategy, transient_attributes = CucumberFactory::BuildStrategy.from_prose(raw_model, raw_variant)
         model_class = build_strategy.model_class
+        attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes, transient_attributes)
+        record = build_strategy.create_record(attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def parse_update(world, raw_model, raw_name, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil)
+        model_class = CucumberFactory::BuildStrategy.parse_model_class(raw_model)
+        attributes = parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes)
+        record = resolve_associated_value(world, model_class, model_class, model_class, raw_name)
+        CucumberFactory::UpdateStrategy.new(record).assign_attributes(attributes)
+        remember_record_names(world, record, attributes)
+        record
+      end
+
+      def parse_attributes(world, model_class, raw_attributes, raw_boolean_attributes, raw_multiline_attributes = nil, transient_attributes = [])
         attributes = {}
         if raw_attributes.try(:strip).present?
           raw_attribute_fragment_regex = /(?:the |and |with |but |,| )+(.*?) (#{VALUE_SCALAR}|#{VALUE_ARRAY}|#{VALUE_LAST_RECORD})/
@@ -126,59 +162,71 @@ module CucumberFactory
           # DocString e.g. "first name: Jane\nlast name: Jenny\n"
           if raw_multiline_attributes.is_a?(String)
             raw_multiline_attributes.split("\n").each do |fragment|
-              raw_attribute, value = fragment.split(': ')
+              raw_attribute, value = fragment.split(': ', 2)
               attribute = attribute_name_from_prose(raw_attribute)
-              value = "\"#{value}\"" unless matches_fully?(value, VALUE_ARRAY)
+              value = "\"#{value}\"" unless matches_fully?(value, /#{VALUE_ARRAY}|#{VALUE_FILE}/)
               attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
             end
           # DataTable e.g. in raw [["first name", "Jane"], ["last name", "Jenny"]]
           else
             raw_multiline_attributes.raw.each do |raw_attribute, value|
               attribute = attribute_name_from_prose(raw_attribute)
-              value = "\"#{value}\"" unless matches_fully?(value, VALUE_ARRAY)
+              value = "\"#{value}\"" unless matches_fully?(value, /#{VALUE_ARRAY}|#{VALUE_FILE}/)
               attributes[attribute] = attribute_value(world, model_class, transient_attributes, attribute, value)
             end
           end
         end
-        record = build_strategy.create_record(attributes)
-        remember_record_names(world, record, attributes)
-        record
+        attributes
       end
 
       def attribute_value(world, model_class, transient_attributes, attribute, value)
-        association_class = resolve_association_class(attribute, model_class, transient_attributes)
-
-        if matches_fully?(value, VALUE_ARRAY)
-          elements_str = unquote(value)
-          value = elements_str.scan(VALUE_SCALAR).map { |v| attribute_value(world, model_class, transient_attributes, attribute, v) }
-        elsif association_class.present?
-          if matches_fully?(value, VALUE_LAST_RECORD)
-            value = CucumberFactory::Switcher.find_last(association_class) or raise Error, "There is no last #{attribute}"
-          elsif matches_fully?(value, VALUE_STRING)
-            value = unquote(value)
-            value = get_named_record(world, value) || transform_value(world, value)
-          elsif matches_fully?(value, VALUE_INTEGER)
-            value = value.to_s
-            value = get_named_record(world, value) || transform_value(world, value)
-          else
-            raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
-          end
+        associated, association_class = resolve_association(attribute, model_class, transient_attributes)
+
+        value = if matches_fully?(value, VALUE_ARRAY)
+          array_values = unquote(value).scan(VALUE_SCALAR)
+          array_values.map { |v| attribute_value(world, model_class, transient_attributes, attribute, v) }
+        elsif associated
+          resolve_associated_value(world, model_class, association_class, attribute, value)
         else
-          value = resolve_scalar_value(world, model_class, attribute, value)
+          resolve_scalar_value(world, model_class, attribute, value)
         end
         value
       end
 
-      def resolve_association_class(attribute, model_class, transient_attributes)
+      def resolve_association(attribute, model_class, transient_attributes)
         return unless model_class.respond_to?(:reflect_on_association)
 
-        klass = if model_class.reflect_on_association(attribute)
-          model_class.reflect_on_association(attribute).klass
+        association = model_class.reflect_on_association(attribute)
+        association_class = nil
+
+        if association
+          association_class = association.klass unless association.polymorphic?
+          associated = true
         elsif transient_attributes.include?(attribute.to_sym)
           klass_name = attribute.to_s.camelize
-          klass_name.constantize if Object.const_defined?(klass_name)
+          if Object.const_defined?(klass_name)
+            association_class = klass_name.constantize
+            associated = true
+          end
         else
-          nil
+          associated = false
+        end
+        [associated, association_class]
+      end
+
+      def resolve_associated_value(world, model_class, association_class, attribute, value)
+        if matches_fully?(value, VALUE_LAST_RECORD)
+          raise(Error, "Cannot set last #{model_class}##{attribute} for polymorphic associations") unless association_class.present?
+
+          CucumberFactory::Switcher.find_last(association_class) || raise(Error, "There is no last #{attribute}")
+        elsif matches_fully?(value, VALUE_STRING)
+          value = unquote(value)
+          get_named_record(world, value) || transform_value(world, value)
+        elsif matches_fully?(value, VALUE_INTEGER)
+          value = value.to_s
+          get_named_record(world, value) || transform_value(world, value)
+        else
+          raise Error, "Cannot set association #{model_class}##{attribute} to #{value}."
         end
       end
 
@@ -190,6 +238,9 @@ module CucumberFactory
           value = value.to_i
         elsif matches_fully?(value, VALUE_DECIMAL)
           value = BigDecimal(value)
+        elsif matches_fully?(value, VALUE_FILE)
+          path = File.path("./#{file_value_to_path(value)}")
+          value = File.new(path)
         else
           raise Error, "Cannot set attribute #{model_class}##{attribute} to #{value}."
         end
@@ -197,11 +248,20 @@ module CucumberFactory
       end
 
       def unquote(string)
+        # This method removes quotes or brackets from the start and end from a string
+        # Examples: 'single' => single, "double" => double, [1, 2, 3] => 1, 2, 3
         string[1, string.length - 2]
       end
 
+      def file_value_to_path(string)
+        # file paths are marked with a special keyword and enclosed with quotes.
+        # Example: file:"/path/image.png"
+        # This will extract the path (/path/image.png) from the text fragment above
+        unquote string.sub(/\Afile:/, '')
+      end
+
       def full_regexp(partial_regexp)
-        Regexp.new("\\A" + partial_regexp.source + "\\z", partial_regexp.options)
+        Regexp.new('\\A(?:' + partial_regexp.source + ')\\z', partial_regexp.options)
       end
 
       def matches_fully?(string, partial_regexp)
@@ -221,7 +281,7 @@ module CucumberFactory
       end
 
       def attribute_name_from_prose(prose)
-        prose.downcase.gsub(" ", "_").to_sym
+        prose.downcase.gsub(' ', '_').to_sym
       end
 
       def remember_record_names(world, record, attributes)