radius-spec 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36a2686c3a5c78dd53ae5155196068a0c363b438edf1e84f64212ce8e7ffe905
-  data.tar.gz: 3600656a4e89595218980fa536a785b94494e5396bb10ecf294cc3741f1a693b
+  metadata.gz: 229205333f0d39f679032b076188c7a18013408c034486de29c4f4a684ddcf74
+  data.tar.gz: 37aa800e6bfdb5b273de8837cbe62f87ca8f4f6b3a93bce091b7bbe6867cd64e
 SHA512:
-  metadata.gz: a8b81229f457df7c5ea6e6d1984ff2d68323b6c1acab81c5c4ede9001ed97f7619f2b355de636f4e72560412185b13c2ec804fc78866d5dcef1e258cde58ddee
-  data.tar.gz: c48a00ab090ace41b513c2007e55ece0aa8b4341bf0747f3aad5f0d11bf11c6745f64fca02d5150ff15f0f72cf1dafc49ed95985b4e744a5f291ea5e247f1eb2
+  metadata.gz: a0dde94d3cb6579e8faf68027cf1f77c1d8268d4d7c1979b05c5554e4e000769e2b6240f398d396558d0c71c2c717ead0062c5f236d4d03a49981fa91c8a95ca
+  data.tar.gz: 027ef0ac9fcbc76dbaa374382035829e7607c4d3dc2979f2bbc8413b7cbd032961760ed798ac1bda7b83fba9899127c82c96743e8d716fca50f2fb93e01bb0bd

data/.yardopts

@@ -1,4 +1,5 @@
 --markup markdown
+--markup-provider redcarpet
 --no-private
 -
 CHANGELOG.md

data/CHANGELOG.md

@@ -1,3 +1,44 @@
+## 0.5.0 (September 26, 2018)
+
+[Full Changelog](https://github.com/RadiusNetworks/radius-spec/compare/v0.4.0...v0.5.0)
+
+### Enhancements
+
+- Add common VCR configuration (Aaron Kromer, #16)
+  - Filters out `Authorization` headers
+  - Filters out the following sensitive/environment varying `ENV` values, as
+    well as their URL and form encoded variants:
+    - `AWS_ACCESS_KEY_ID`
+    - `AWS_SECRET_ACCESS_KEY`
+    - `GOOGLE_CLIENT_ID`
+    - `GOOGLE_CLIENT_SECRET`
+    - `RADIUS_OAUTH_PROVIDER_APP_ID`
+    - `RADIUS_OAUTH_PROVIDER_APP_SECRET`
+    - `RADIUS_OAUTH_PROVIDER_URL`
+- Add "temp file" helpers for working with file stubs (Aaron Kromer, #15)
+- Upgrade to Rubocop 0.59.x (Aaron Kromer, #14)
+- Adjust common Rubocop configuration (Aaron Kromer, #14)
+  - `Layout/EmptyLineAfterGuardClause` is enabled by default
+  - Enable `Rails/SaveBang` to highlight potential lurking issues
+  - Expand `Rails/FindBy` and `Rails/FindEach` to check all `/app` and `/lib`
+  - Add more functional methods
+    - `default_scope`
+    - `filter_sensitive_data`
+- Add `build!` factory method to compliment `build` to help resolving Rubocop
+  violations for `Rails/SaveBang` (Aaron Kromer, #14)
+- Load model factory for specs tagged with 'type: :mailer' (Aaron Kromer, #11)
+- Include the following negated RSpec matchers (Aaron Kromer, #12)
+  - `exclude` / `excluding`
+  - `not_eq`
+  - `not_change`
+  - `not_raise_error` / `not_raise_exception`
+
+### Bug Fixes
+
+- Fix `NoMethodError: undefined method 'strip'` when the fixture path is a
+  `Pathname` object (Aaron Kromer, #13)
+
+
 ## 0.4.0 (July 10, 2018)
 
 [Full Changelog](https://github.com/RadiusNetworks/radius-spec/compare/v0.3.0...v0.4.0)
@@ -88,7 +129,7 @@
 
 ### Bug Fixes
 
-- Fix `NameError: undefined local variable or method `config` for Rails RSpec
+- Fix `NameError: undefined local variable or method config` for Rails RSpec
   configuration (Aaron Kromer, #1)
 - Fix model factory build issue in which registered template attributes, which
   use symbol keys, are not replaced by custom attributes using string keys

data/Gemfile

@@ -16,10 +16,10 @@ end
 
 group :debug do
   gem "pry-byebug", "~> 3.6", require: false
-  gem "travis", require: false
 end
 
 group :documentation do
+  gem 'redcarpet', require: false
   gem 'yard', '~> 0.9', require: false
 end
 

data/README.md

@@ -249,7 +249,7 @@ constant so no changes need to be made if that's your preference.
 
 Attribute keys may be defined using either strings or symbols. However, they
 will be stored internally as symbols. This means that when an object instance
-is create using the factory the attribute hash will be provided to `new` with
+is created using the factory the attribute hash will be provided to `new` with
 symbol keys.
 
 ##### Dynamic Attribute Values (i.e. Generators)
@@ -418,26 +418,26 @@ There are a few behaviors to note for using the builder:
 
 ##### Optional Block
 
-Both `build` and `create` support providing an optional block. This block is
+Both `build` and `build!` support providing an optional block. This block is
 passed directly to `new` when creating the object. This is to support the
 common Ruby idiom of yielding `self` within initialize:
 
-  ```ruby
-  class AnyClass
-    def initialize(attrs = {})
-      # setup attrs
-      yield self if block_given?
-    end
+```ruby
+class AnyClass
+  def initialize(attrs = {})
+    # setup attrs
+    yield self if block_given?
   end
+end
 
-  RSpec.describe AnyClass, :model_factory do
-    it "passes the block to the object initializer" do
-      block_capture = nil
-      an_object = build("AnyClass") { |instance| block_capture = instance }
-      expect(block_capture).to be an_object
-    end
+RSpec.describe AnyClass, :model_factory do
+  it "passes the block to the object initializer" do
+    block_capture = nil
+    an_object = build("AnyClass") { |instance| block_capture = instance }
+    expect(block_capture).to be an_object
   end
-  ```
+end
+```
 
 Since Ruby always supports passing a block to a method, even if the method does
 not use the block, it's possible the block will not run if the class being
@@ -451,29 +451,328 @@ this feature.
 
 We suggest that you create instances using the following syntax:
 
-  ```ruby
-  created_instance = build("AnyClass").tap(&:save!)
-  ```
+```ruby
+let(:an_instance) { build("AnyClass") }
 
-Or alternatively:
+before do
+  an_instance.save!
+end
+```
 
-  ```ruby
-  let(:an_instance) { build("AnyClass") }
+Or alternatively:
 
-  before do
-    an_instance.save!
-  end
-  ```
+```ruby
+created_instance = build("AnyClass")
+created_instance.save!
+```
 
 This way it is explicit what objects need to be persisted and in what order.
 
-However, many of our existing projects use a legacy `create` helper. This is
-simply a wrapper around `build.tap(&:save!)`, but it supports omitting the
-`save!` call for objects which do not support it.
+This can get tedious at times, especially for those who only need to create an
+object to embed as an attribute of another object:
+
+```ruby
+collaborator = build("AnotherClass")
+collaborator.save!
+
+# collaborator is not used against directly after this line
+created_instance = build("AnyClass", collaborator: collaborator)
+created_instance.save!
+```
+
+For these cases the `build!` helper is available. This is simply an alias for
+`build.tap(&:save!)`, but it supports omitting the `save!` call for objects
+which do not support it. While it provides a safety guarantee that `save!` will
+be called (instead of potentially `save`) it is less explicit.
+
+```ruby
+created_instance = build("AnyClass", collaborator: build!("AnotherClass"))
+created_instance.save!
+```
+
+We still discourage the use of `build!` directly in `let` blocks for all of the
+above mentioned reasons.
+
+##### Legacy "Creating" Instances
+
+Many of our existing projects use a legacy `create` helper. This is simply an
+alias for `build!`. It is provided only for backwards compatibility support and
+will be removed in a future release. New code should not use this method.
+
+```ruby
+created_instance = create("AnyClass")
+```
+
+### Negated Matchers
+
+This gem defines the following [negated matchers](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/define-negated-matcher)
+to allow for use [composing matchers](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/composing-matchers)
+and with [compound expectations](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/compound-expectations).
+
+| Matcher               | Inverse Of |
+|-----------------------|------------|
+| `exclude`             | [`include`](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/built-in-matchers/include-matcher) |
+| `excluding`           | [`including`](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/built-in-matchers/include-matcher) |
+| `not_eq`              | [`eq`](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/built-in-matchers/equality-matchers#compare-using-eq-(==)) |
+| `not_change`          | [`change`](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/built-in-matchers/change-matcher) |
+| `not_raise_error`     | [`raise_error`](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/built-in-matchers/raise-error-matcher) |
+| `not_raise_exception` | [`raise_exception`](https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/built-in-matchers/raise-error-matcher) |
+
+#### Composing Matchers
+
+There is no equivalent of `not_to` for composed matchers when only a subset of
+the values needs to be negated. The negated matchers allow this type of fine
+grain comparison:
+
+```ruby
+x = [1, 2, :value]
+expect(x).to contain_exactly(be_odd, be_even, not_eq(:target))
+```
+
+This also works for verifying / stubbing a message with argument constraints:
+
+```ruby
+allow(obj).to receive(:meth).with(1, 2, not_eq(5))
+obj.meth(1, 2, 3)
+expect(obj).to have_received(:meth).with(not_eq(2), 2, 3)
+```
+
+This is great for verifying option hashes:
+
+```ruby
+expect(obj).to have_received(:meth).with(
+  some_value,
+  excluding(:some_opt, :another_opt),
+)
+```
+
+#### Compound Negated Matchers
+
+Normally it's not possible to chain to a negative match:
+
+```ruby
+a = b = 0
+expect {
+  a = 1
+}.not_to change {
+  b
+}.from(0).and change {
+  a
+}.to(1)
+```
+
+Fails with:
+
+    NotImplementedError:
+      `expect(...).not_to matcher.and matcher` is not supported, since it creates
+      a bit of an ambiguity. Instead, define negated versions of whatever
+      matchers you wish to negate with `RSpec::Matchers.define_negated_matcher`
+      and use `expect(...).to matcher.and matcher`.
+
+Per the error the negated matcher allows for the following:
+
+```ruby
+a = b = 0
+expect {
+  a = 1
+}.to change {
+  a
+}.to(1).and not_change {
+  b
+}.from(0)
+```
+
+Similarly, complex expectations can be set on lists:
+
+```ruby
+a = %i[red blue green]
+expect(a).to include(:red).and exclude(:yellow)
+expect(a).to exclude(:yellow).and include(:red)
+```
+
+### Working with Temp Files
+
+These helpers are meant to ease the creation of temporary files to either stub
+the data out or provide a location for data to be saved then verified.
+
+In the case of file stubs, using these helpers allows you to co-locate the file
+data with the specs. This makes it easy for someone to read the spec and
+understand the test case; instead of having to find a fixture file and look at
+its data. This also makes it easy to change the data between specs, allowing
+them to focus on just what they need.
+
+#### Usage
+
+There are multiple ways you can use these helpers. Which method you choose
+depends on how much perceived magic/syntactic sugar you want:
+
+  - Call the helpers directly on the module:
+
+    ```ruby
+    require 'radius/spec/tempfile'
+
+    def write_hello_world(filepath)
+      File.write filepath, "Hello World"
+    end
+
+    Radius::Spec::Tempfile.using_tempfile do |pathname|
+      write_hello_world pathname
+      File.read(pathname)
+      # => "Hello World"
+    end
+    ```
+  - Include the helper methods explicitly:
+
+    ```ruby
+    require 'radius/spec/tempfile'
+
+    RSpec.describe AnyClass do
+      include Radius::Spec::Tempfile
+
+      it "includes the file helpers" do
+        using_tempfile do |pathname|
+          code_under_test pathname
+          expect(pathname.read).to eq "Any written data"
+        end
+      end
+    end
+    ```
+  - Include the helper methods via metadata:
+
+    ```ruby
+    RSpec.describe AnyClass do
+      it "includes the file helpers", :tempfile do
+        using_tempfile do |pathname|
+          code_under_test pathname
+          expect(pathname.read).to eq "Any written data"
+        end
+      end
+    end
+    ```
+
+    When using this metadata option you do not need to explicitly require the
+    tempfile feature. This gem registers metadata with the RSpec configuration
+    when it loads and `RSpec` is defined. When the metadata is first used it
+    will automatically require the tempfile feature and include the helpers.
+
+    Any of following metadata will include the factory helpers:
+
+      - `:tempfile`
+      - `:tmpfile`
+
+There are a few additional behaviors to note:
+
+  - Data can be stubbed by the helper through the `data` keyword arg:
+
+    ```ruby
+    stub_data = "Any file stub data text."
+    Radius::Spec::Tempfile.using_tempfile(data: stub_data) do |stubpath|
+      File.read(stubpath)
+      # => "Any file stub data text."
+    end
+    ```
+
+    It can even be inlined using heredocs:
+
+    ```ruby
+    Radius::Spec::Tempfile.using_tempfile(data: <<~TEXT) do |stubpath|
+      Any file stub data text.
+    TEXT
+      # Yard formats heredoc args oddly
+      File.read(stubpath)
+      # => "Any file stub data text.\n"
+    end
+    ```
+
+    > NOTE: That when inlining like this heredocs add an extra new line. To
+    > remove it use `.chomp` on the kwarg:
+    >
+    > ```ruby
+    > using_tempfile(data: <<~TEXT.chomp) do |pathname|
+    >   This has no newline.
+    > TEXT
+    >   # ...
+    > end
+    > ```
+
+  - Additional arguments and options are forwarded directly to
+    [Tempfile.create](https://ruby-doc.org/stdlib/libdoc/tempfile/rdoc/Tempfile.html#method-c-create)
+
+    This allows you to set custom file extensions:
+
+    ```ruby
+    Radius::Spec::Tempfile.using_tempfile(%w[custom_name .myext]) do |pathname|
+      pathname.extname
+      # => ".myext"
+    end
+    ```
+
+    Or change the file encoding:
+
+    ```ruby
+    Radius::Spec::Tempfile.using_tempfile(encoding: "ISO-8859-1", data: <<~DATA) do |pathname|
+      Résumé
+    DATA
+      # Yard formats heredoc args oddly
+      File.read(pathname)
+      # => "R\xE9sum\xE9\n"
+    end
+    ```
+
+### Common VCR Configuration
+
+A project must include both [`vcr`](https://rubygems.org/gems/vcr) and
+[`webmock`](https://rubygems.org/gems/webmock) to use this configuration.
+Neither of those gems will be installed as dependencies of this gem. This is
+intended to give projects more flexibility in choosing which additional features
+they will use.
+
+The main `radius/spec/rspec` setup will load the common VCR configuration
+automatically when a spec is tagged with the `:vcr` metadata. This will
+configure VCR to:
+
+  - save specs to `/spec/cassettes`
+
+  - use record mode `once` when a single spec or spec file is run
+
+    This helps ease the development of new specs without requiring any
+    configuration / setting changes.
+
+  - uses record mode `none` otherwise, along setting VCR to fail when unused
+    interactions remain in a cassette
+
+    This is intended to better alert developers to unexpected side effects of
+    changes as any addition or removal of a request will cause a failure.
+
+  - all `Authorization` HTTP headers are filtered by default
+
+    This is a common oversight when recording specs. Often token based
+    authentication is picked up by the other filtered environment settings, but
+    basic authentication is not. Additionally, certain types of digest
+    authentication may cause specs to leak state. This filtering guards all of
+    these cases from accidental credential leak.
+
+  - the following common sensitive, or often environment variable, settings are
+    filtered
+
+    Those settings which often change between developer machines, and even the
+    CI server, can cause for flaky specs. It may also be frustrating for
+    developers to have to adjust their local systems to match others just to
+    get a few specs to pass. This is intended to help mitigate those issues:
+
+    - `AWS_ACCESS_KEY_ID`
+    - `AWS_SECRET_ACCESS_KEY`
+    - `GOOGLE_CLIENT_ID`
+    - `GOOGLE_CLIENT_SECRET`
+    - `RADIUS_OAUTH_PROVIDER_APP_ID`
+    - `RADIUS_OAUTH_PROVIDER_APP_SECRET`
+    - `RADIUS_OAUTH_PROVIDER_URL`
+
+  - a project's local `support/vcr.rb` file will be loaded after the common
+    VCR configuration loads; if it's available
 
-  ```ruby
-  created_instance = create("AnyClass")
-  ```
+    This allows projects to overwrite common settings if they need to, as well,
+    as add on addition settings or filtering of data.
 
 ## Development
 

data/benchmarks/bm_setup.rb

@@ -38,6 +38,7 @@ def as_boolean(val, default: nil)
     false
   else
     raise "Unknown boolean value #{val}" if default.nil?
+
     default
   end
 end

data/common_rubocop.yml

@@ -106,6 +106,10 @@ Metrics/BlockLength:
     - 'spec/spec_helper.rb'
     - 'spec/**/*_spec.rb'
     - 'spec/support/model_factories.rb'
+  ExcludedMethods:
+    - 'refine'
+    - 'RSpec.configure'
+    - 'VCR.configure'
 
 # We generally prefer to use the default line length of 80. Though sometimes
 # we just need a little extra space because it makes it easier to read.
@@ -266,7 +270,9 @@ Style/BlockDelimiters:
     - create!
     - build
     - build!
+    - default_scope
     - each_with_object
+    - filter_sensitive_data
     - find
     - git_source
     - let
@@ -280,6 +286,19 @@ Style/BlockDelimiters:
     - proc
     - it
 
+# Prefer `Time` over `DateTime`.
+#
+# While these are not necessarily interchangeable we prefer `Time`. According
+# to the Ruby docs `DateTime` is meant more for historical dates; it also does
+# not consider leap seconds or summer time rules.
+#
+# Lastly, `DateTime` is part of the stdlib which is written in Ruby; where as
+# `Time` is part of core and written in C.
+#
+# Configuration parameters: AllowCoercion
+Style/DateTime:
+  Enabled: true
+
 # The double negation idiom is a common Ruby-ism. All languages have various
 # idioms and part of learning the language is learning the common idioms. Once
 # learning the meaning it is not cryptic as Rubocop implies.
@@ -391,9 +410,10 @@ Style/MethodCalledOnDoEndBlock:
 Style/MultilineBlockChain:
   Enabled: false
 
-# Context for this cop is too dependent. Often using the numeric comparison is
-# faster. An in certain contexts, Also, depending on the context a numeric
-# comparison is more consistent and can even be more natural:
+# Context for this cop is too dependent.
+#
+# Often using the numeric comparison is faster. Also, depending on the context
+# a numeric comparison may produce a more consistent style:
 #
 #     # numeric comparison is more natural and consistent
 #     if n < 0

data/common_rubocop_rails.yml

@@ -106,6 +106,34 @@ Rails/ApplicationRecord:
 Rails/CreateTableWithTimestamps:
   Enabled: false
 
+# Usage of `find_by` is more expressive of intent than `where.first`. We should
+# check all app code, not just the models to improve intent expression.
+#
+# Since rake tasks often live in `lib` we also check all of lib as well.
+#
+# Configuration parameters: Include.
+# Include: app/models/**/*.rb
+Rails/FindBy:
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+    - 'lib/**/*.rb'
+
+# Usage of `each` for large datasets can be a performance issue; specially a
+# drain on system memory. When possible it's better to use `find_each` so that
+# chunks of data are evaluated at a time.
+#
+# We should check all app code, not just the models to help prevent this. Since
+# rake tasks often live in `lib` we also check all of lib as well.
+#
+# Configuration parameters: Include.
+# Include: app/models/**/*.rb
+Rails/FindEach:
+  Enabled: true
+  Include:
+    - 'app/**/*.rb'
+    - 'lib/**/*.rb'
+
 # We understand the trade-offs for using the through model versus a lookup
 # table. As such this cop is just noise as it flags only those cases we really
 # do want a lookup table.
@@ -122,7 +150,7 @@ Rails/HasAndBelongsToMany:
 # For most of us `unless blank?` reads just as easily as `if present?`.
 # Sometimes contextually, it can read better depending on the branch logic and
 # surrounding context. As `if present?` requires an additional negation and
-# method call it is technically slower. In the general case the perf different
+# method call it is technically slower. In the general case the perf difference
 # isn't much but in some cases it matters. Thus, we are not enforcing changing
 # `unless blank?` to `if present?` and are leaving it up to the context to
 # decide which is a better fit.
@@ -144,6 +172,37 @@ Rails/Present:
 Rails/ReadWriteAttribute:
   Enabled: false
 
+# This ensures we do not ignore potential validation issues in the code. Doing
+# so can lead to strange and surprising bugs where records are expected to
+# be created, or be modified, but are not.
+#
+#     # If author is a new record the book may not be created since the FK is
+#     # invalid. Perhaps omitting other fields, maybe new required fields, is
+#     # an oversight in the book creation as well.
+#     author.save
+#     Book.create(author: author)
+#
+# Or side effects are expected to occur but they do not:
+#
+#     # This is a condensed default Rails scaffold controller for `destroy`.
+#     #
+#     # Once a `has_many` or `has_one` associations is added which specifies
+#     # `dependent: :restrict_with_error` this no longer behaves as expected.
+#     # Given such associations are often added much later in time errors in
+#     # this action are an all to common oversight in Rails.
+#     def destroy
+#       @book.destroy
+#       respond_to do |format|
+#         format.html do
+#           redirect_to books_url, notice: 'Book was successfully destroyed.'
+#         end
+#       end
+#     end
+#
+# Configuration parameters: AllowImplicitReturn, AllowedReceivers.
+Rails/SaveBang:
+  Enabled: true
+
 # According to the Rails docs while the following methods skip validations they
 # only update the specified (single) attribute reducing risks. We'd rather not
 # warn for those cases:

data/lib/radius/spec/model_factory.rb

@@ -268,6 +268,7 @@ module Radius
         def safe_transform(value)
           return value.call if value.is_a?(Proc)
           return value if value.frozen?
+
           value.dup
         end
 
@@ -426,44 +427,56 @@ module Radius
 
       # Convenience wrapper for building, and persisting, a model template.
       #
-      # This is a thin wrapper around `build(name, attrs).tap(&:save!)`. The
-      # persistence message `save!` will only be called on objects which
-      # respond to it.
-      #
-      # ### Avoid for New Code
+      # This is a thin wrapper around:
       #
-      # It is strongly suggested that you avoid using `create` for new code.
-      # Instead be explicit about when and how objects are persisted. This
-      # allows you to have fine grain control over how your data is setup.
+      # ```ruby
+      # build(name, attrs, &block).tap(&:save!)
+      # ```
       #
-      # We suggest that you create instances which need to be persisted before
-      # your specs using the following syntax:
+      # The persistence message `save!` will only be called on objects which
+      # respond to it.
       #
-      # ```ruby
-      # let(:an_instance) { build("AnyClass") }
+      # @note It is generally suggested that you avoid using `build!` for new
+      #   code. Instead be explicit about when and how objects are persisted.
+      #   This allows you to have fine grain control over how your data is
+      #   setup.
       #
-      # before do
-      #   an_instance.save!
-      # end
-      # ```
+      #   We suggest that you create instances which need to be persisted
+      #   before your specs using the following syntax:
       #
-      # Alternatively if you really want for the instance be lazy instantiated,
-      # and persisted, pass the appropriate persistence method as the block:
+      #   ```ruby
+      #   let(:an_instance) { build("AnyClass") }
       #
-      # ```ruby
-      # let(:an_instance) { build("AnyClass", &:save!) }
-      # ```
+      #   before do
+      #     an_instance.save!
+      #   end
+      #   ```
       #
       # @param (see .build)
       # @return (see .build)
       # @raise (see .build)
       # @see .build
       # @see .define_factory
-      def create(name, custom_attrs = {}, &block)
+      # @since 0.5.0
+      def build!(name, custom_attrs = {}, &block)
         instance = build(name, custom_attrs, &block)
         instance.save! if instance.respond_to?(:save!)
         instance
       end
+
+      # Legacy helper provided for backwards compatibility support.
+      #
+      # This provides the same behavior as {.build!} and will be removed in a
+      # future release.
+      #
+      # @param (see .build)
+      # @return (see .build)
+      # @raise (see .build)
+      # @see .build
+      # @see .define_factory
+      def create(name, custom_attrs = {}, &block)
+        build!(name, custom_attrs, &block)
+      end
     end
   end
 end

data/lib/radius/spec/rails.rb

@@ -7,7 +7,7 @@ require 'rspec/rails'
 
 RSpec.configure do |config|
   # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
-  config.fixture_path = ::Rails.root.join("spec", "fixtures")
+  config.fixture_path = ::Rails.root.join("spec", "fixtures").to_path
 
   # If you're not using ActiveRecord, or you'd prefer not to run each of your
   # examples within a transaction, remove the following line or assign false

data/lib/radius/spec/rspec.rb

@@ -109,6 +109,11 @@ RSpec.configure do |config|
     config.include Radius::Spec::ModelFactory, :model_factory, :model_factories
   end
 
+  config.when_first_matching_example_defined(:tempfile, :tmpfile) do
+    require 'radius/spec/tempfile'
+    config.include Radius::Spec::Tempfile, :tempfile, :tmpfile
+  end
+
   config.when_first_matching_example_defined(type: :controller) do
     require 'radius/spec/model_factory'
     config.include Radius::Spec::ModelFactory, type: :controller
@@ -124,6 +129,11 @@ RSpec.configure do |config|
     config.include Radius::Spec::ModelFactory, type: :job
   end
 
+  config.when_first_matching_example_defined(type: :mailer) do
+    require 'radius/spec/model_factory'
+    config.include Radius::Spec::ModelFactory, type: :mailer
+  end
+
   config.when_first_matching_example_defined(type: :model) do
     require 'radius/spec/model_factory'
     config.include Radius::Spec::ModelFactory, type: :model
@@ -138,4 +148,14 @@ RSpec.configure do |config|
     require 'radius/spec/model_factory'
     config.include Radius::Spec::ModelFactory, type: :system
   end
+
+  config.when_first_matching_example_defined(:webmock) do
+    require 'webmock/rspec'
+  end
+
+  config.when_first_matching_example_defined(:vcr, :vcr_record, :vcr_record_new) do
+    require 'radius/spec/vcr'
+  end
 end
+
+require 'radius/spec/rspec/negated_matchers'

data/lib/radius/spec/rspec/negated_matchers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# Define negated matchers for use with composable matchers and compound
+# expectations.
+#
+# @see https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/composing-matchers
+# @see https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/compound-expectations
+RSpec::Matchers.define_negated_matcher :exclude, :include
+RSpec::Matchers.define_negated_matcher :excluding, :including
+RSpec::Matchers.define_negated_matcher :not_eq, :eq
+
+# Allows us to check that a block doesn't raise an exception while also
+# checking for other changes using compound expectations; since you can't chain
+# a negative (`not_to`) with any other matchers
+#
+# @see https://relishapp.com/rspec/rspec-expectations/v/3-8/docs/compound-expectations
+RSpec::Matchers.define_negated_matcher :not_change, :change
+RSpec::Matchers.define_negated_matcher :not_raise_error, :raise_error
+RSpec::Matchers.define_negated_matcher :not_raise_exception, :raise_exception

data/lib/radius/spec/tempfile.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require 'pathname'
+require 'tempfile'
+
+module Radius
+  module Spec
+    # Temporary file helpers
+    #
+    # These helpers are meant to ease the creation of temporary files to either
+    # stub the data out or provide a location for data to be saved then
+    # verified.
+    #
+    # In the case of file stubs, using these helpers allows you to co-locate
+    # the file data with the specs. This makes it easy for someone to read the
+    # spec and understand the test case; instead of having to find a fixture
+    # file and look at its data. This also makes it easy to change the data
+    # between specs, allowing them to focus on just what they need.
+    #
+    # To make these helpers available require them after the gem:
+    #
+    # ```ruby
+    # require 'radius/spec'
+    # require 'radius/spec/tempfile'
+    # ```
+    #
+    # ### Including Helpers in Specs
+    #
+    # There are multiple ways you can use these helpers. Which method you
+    # choose depends on how much perceived magic/syntactic sugar you want:
+    #
+    #   - call the helpers directly on the module
+    #   - manually include the helper methods in the specs
+    #   - use metadata to auto load this feature and include it in the specs
+    #
+    # When using the metadata option you do not need to explicitly require the
+    # module. This gem registers metadata with the RSpec configuration when it
+    # loads and `RSpec` is defined. When the matching metadata is first used it
+    # will automatically require and include the helpers.
+    #
+    # Any of following metadata will include the factory helpers:
+    #
+    #   - `:tempfile`
+    #   - `:tmpfile`
+    #
+    # @example use a helper directly in specs
+    #   require 'radius/spec/tempfile'
+    #
+    #   RSpec.describe AnyClass do
+    #     it "includes the file helpers" do
+    #       Radius::Spec::Tempfile.using_tempfile do |pathname|
+    #         code_under_test pathname
+    #         expect(pathname.read).to eq "Any written data"
+    #       end
+    #     end
+    #   end
+    # @example manually include the helpers
+    #   require 'radius/spec/tempfile'
+    #
+    #   RSpec.describe AnyClass do
+    #     include Radius::Spec::Tempfile
+    #     it "includes the file helpers" do
+    #       using_tempfile do |pathname|
+    #         code_under_test pathname
+    #         expect(pathname.read).to eq "Any written data"
+    #       end
+    #     end
+    #   end
+    # @example use metadata to auto include the helpers
+    #   RSpec.describe AnyClass do
+    #     it "includes the file helpers", :tempfile do
+    #       using_tempfile do |pathname|
+    #         code_under_test pathname
+    #         expect(pathname.read).to eq "Any written data"
+    #       end
+    #     end
+    #   end
+    # @since 0.5.0
+    module Tempfile
+    module_function
+
+      # Convenience wrapper for managaing temporary files.
+      #
+      # This creates a temporary file and yields its path to the provided
+      # block. When the block returns the temporary file is deleted.
+      #
+      # ### Optional Parameters
+      #
+      # The block is required. All other parameters are optional. All
+      # parameters except `data` are Ruby version dependent and will be
+      # forwarded directly to the stdlib's
+      # {https://ruby-doc.org/stdlib/libdoc/tempfile/rdoc/Tempfile.html#method-c-create
+      # `Tempfile.create`}. The when the `data` parameter is provided it's
+      # contents will be written to the temporary file prior to yielding to the
+      # block.
+      #
+      # @example creating a tempfile to pass to code
+      #   def write_hello_world(filepath)
+      #     File.write filepath, "Hello World"
+      #   end
+      #
+      #   Radius::Spec::Tempfile.using_tempfile do |pathname|
+      #     write_hello_world pathname
+      #   end
+      # @example creating a file stub
+      #   stub_data = "Any file stub data text."
+      #   Radius::Spec::Tempfile.using_tempfile(data: stub_data) do |stubpath|
+      #     # File.read(stubpath)
+      #     # => "Any file stub data text."
+      #     code_under_test stubpath
+      #   end
+      # @example creating a file stub inline
+      #   Radius::Spec::Tempfile.using_tempfile(data: <<~TEXT) do |stubpath|
+      #     Any file stub data text.
+      #   TEXT
+      #     # File.read(stubpath)
+      #     # => "Any file stub data text.\n"
+      #     code_under_test stubpath
+      #   end
+      # @example creating a file stub inline without trailing newline
+      #   Radius::Spec::Tempfile.using_tempfile(data: <<~TEXT.chomp) do |stubpath|
+      #     Any file stub data text.
+      #   TEXT
+      #     # File.read(stubpath)
+      #     # => "Any file stub data text."
+      #     code_under_test stubpath
+      #   end
+      # @example writing binary data inline
+      #   Radius::Spec::Tempfile.using_tempfile(encoding: Encoding::BINARY, data: <<~BIN.chomp) do |binpath|
+      #     \xC8\x90\xC5\x9D\xE1\xB9\x95\xC4\x93\xC4\x89
+      #   BIN
+      #     # File.read(binpath)
+      #     # => "Ȑŝṕēĉ"
+      #     code_under_test binpath
+      #   end
+      # @param args [Object] addition file creation options
+      #
+      #   Passed directly to {https://ruby-doc.org/stdlib/libdoc/tempfile/rdoc/Tempfile.html#method-c-create
+      #   `Tempfile.create`}; see the stdlib docs for details on available
+      #   options.
+      # @param data [String] stub data to write to the file before yielding
+      # @param kwargs [Hash{Symbol => Object}] addition file creation options
+      #
+      #   Passed directly to {https://ruby-doc.org/stdlib/libdoc/tempfile/rdoc/Tempfile.html#method-c-create
+      #   `Tempfile.create`}; see the stdlib docs for details on available
+      #   options.
+      # @yieldparam pathname [Pathname] {https://ruby-doc.org/stdlib/libdoc/pathname/rdoc/Pathname.html path}
+      #   of the created temporary file
+      # @note A block must be provided
+      # @see https://ruby-doc.org/stdlib/libdoc/pathname/rdoc/Pathname.html Pathname
+      # @see https://ruby-doc.org/stdlib/libdoc/tempfile/rdoc/Tempfile.html Tempfile
+      def using_tempfile(*args, data: nil, **kwargs)
+        args << 'tmpfile' if args.empty?
+        ::Tempfile.create(*args, **kwargs) do |f|
+          f.write(data)
+          f.close
+          yield Pathname(f.path)
+        end
+      end
+    end
+  end
+end

data/lib/radius/spec/vcr.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'webmock/rspec'
+require 'vcr'
+
+VCR.configure do |config|
+  config.cassette_library_dir = "spec/cassettes"
+  config.hook_into :webmock
+  config.configure_rspec_metadata!
+  config.ignore_localhost = true
+
+  record_mode = case
+                when RSpec.configuration.files_to_run.one?
+                  # When developing new features we often run new specs in
+                  # isolation as we write the code. This is the time to allow
+                  # creating the cassettes.
+                  :once
+                when ENV['CI']
+                  # Never let CI record
+                  :none
+                else
+                  # Default to blocking new requests to catch issues
+                  :none
+                end
+  config.default_cassette_options = {
+    record: record_mode,
+
+    # Required for working proxy
+    update_content_length_header: true,
+
+    # Raise errors when recorded cassettes no longer match interactions
+    allow_unused_http_interactions: false,
+  }
+
+  # Filter out common sensitive or environment specific data
+  %w[
+    AWS_ACCESS_KEY_ID
+    AWS_SECRET_ACCESS_KEY
+    GOOGLE_CLIENT_ID
+    GOOGLE_CLIENT_SECRET
+    RADIUS_OAUTH_PROVIDER_APP_ID
+    RADIUS_OAUTH_PROVIDER_APP_SECRET
+    RADIUS_OAUTH_PROVIDER_URL
+  ].each do |secret|
+    config.filter_sensitive_data("<#{secret}>") { ENV[secret] }
+
+    config.filter_sensitive_data("<#{secret}_FORM>") {
+      URI.encode_www_form_component(ENV[secret]) if ENV[secret]
+    }
+
+    config.filter_sensitive_data("<#{secret}_URI>") {
+      ERB::Util.url_encode(ENV[secret]) if ENV[secret]
+    }
+
+    config.filter_sensitive_data('<AUTHORIZATION_HEADER>') { |interaction|
+      interaction.request.headers['Authorization']&.first
+    }
+  end
+end
+
+RSpec.configure do |config|
+  {
+    vcr_record: :once,
+    vcr_record_new: :new_episodes,
+  }.each do |tag, record_mode|
+    config.define_derived_metadata(tag) do |metadata|
+      case metadata[:vcr]
+      when nil, true
+        metadata[:vcr] = { record: record_mode }
+      when Hash
+        metadata[:vcr][:record] = record_mode
+      else
+        raise "Unknown VCR metadata value: #{metadata[:vcr].inspect}"
+      end
+    end
+  end
+
+  config.define_derived_metadata(:focus) do |metadata|
+    # VCR is flagged as falsey
+    next if metadata.key?(:vcr) && !metadata[:vcr]
+
+    case metadata[:vcr]
+    when nil, true
+      metadata[:vcr] = { record: :once }
+    when Hash
+      metadata[:vcr][:record] ||= :once
+    else
+      raise "Unknown VCR metadata value: #{metadata[:vcr].inspect}"
+    end
+  end
+end
+
+# Try to any custom VCR config for the app
+# rubocop:disable Lint/HandleExceptions
+begin
+  require 'support/vcr'
+rescue LoadError
+  # Ignore as this is an optional convenience feature
+end
+# rubocop:enable Lint/HandleExceptions

data/lib/radius/spec/version.rb

@@ -2,6 +2,6 @@
 
 module Radius
   module Spec
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

data/radius-spec.gemspec

@@ -31,7 +31,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.5"
 
   spec.add_runtime_dependency "rspec", "~> 3.7"
-  spec.add_runtime_dependency "rubocop", "~> 0.58.1"
+  spec.add_runtime_dependency "rubocop", "~> 0.59.1"
 
   spec.add_development_dependency "bundler", "~> 1.16"
   spec.add_development_dependency "rake", "~> 12.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: radius-spec
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Radius Networks
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-10 00:00:00.000000000 Z
+date: 2018-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.58.1
+        version: 0.59.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.58.1
+        version: 0.59.1
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -109,7 +109,6 @@ files:
 - bin/rspec
 - bin/rubocop
 - bin/setup
-- bin/travis
 - bin/yard
 - common_rubocop.yml
 - common_rubocop_rails.yml
@@ -117,6 +116,9 @@ files:
 - lib/radius/spec/model_factory.rb
 - lib/radius/spec/rails.rb
 - lib/radius/spec/rspec.rb
+- lib/radius/spec/rspec/negated_matchers.rb
+- lib/radius/spec/tempfile.rb
+- lib/radius/spec/vcr.rb
 - lib/radius/spec/version.rb
 - radius-spec.gemspec
 homepage: https://github.com/RadiusNetworks/radius-spec
@@ -124,8 +126,8 @@ licenses:
 - Apache-2.0
 metadata:
   bug_tracker_uri: https://github.com/RadiusNetworks/radius-spec/issues
-  changelog_uri: https://github.com/RadiusNetworks/radius-spec/blob/v0.4.0/CHANGELOG.md
-  source_code_uri: https://github.com/RadiusNetworks/radius-spec/tree/v0.4.0
+  changelog_uri: https://github.com/RadiusNetworks/radius-spec/blob/v0.5.0/CHANGELOG.md
+  source_code_uri: https://github.com/RadiusNetworks/radius-spec/tree/v0.5.0
 post_install_message: 
 rdoc_options: []
 require_paths:

data/bin/travis

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-# frozen_string_literal: true
-
-#
-# This file was generated by Bundler.
-#
-# The application 'travis' is installed as part of a gem, and
-# this file is here to facilitate running it.
-#
-
-require "pathname"
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile",
-  Pathname.new(__FILE__).realpath)
-
-bundle_binstub = File.expand_path("../bundle", __FILE__)
-
-if File.file?(bundle_binstub)
-  if File.read(bundle_binstub, 150) =~ /This file was generated by Bundler/
-    load(bundle_binstub)
-  else
-    abort("Your `bin/bundle` was not generated by Bundler, so this binstub cannot run.
-Replace `bin/bundle` by running `bundle binstubs bundler --force`, then run this command again.")
-  end
-end
-
-require "rubygems"
-require "bundler/setup"
-
-load Gem.bin_path("travis", "travis")