interactor-schema 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1ecc8a0bdc552d23ab22db288cef8ba75f496eec
+  data.tar.gz: 332f9271bcde51e416b2e65fe9a1337c873d8a10
+SHA512:
+  metadata.gz: 3390e8c315799c36e88f643cfaa2b5c11bf7bcc8b775e0b727ffff69580d0ad824f064a50f8221e3b01e07da34de9d3bcc58860dcd86506852913b6876432cad
+  data.tar.gz: 338f3d9000de50f1b1d97ea89947ed174911c6e6d51c6ca7946317378e4df71c760b68635f66c684810ae30912995967a26716db39918d69811a950133e8f5a8

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--order random
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.13.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in interactor-schema.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Bernardo Farah
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,175 @@
+# Interactor::Schema
+
+[![Build Status](https://img.shields.io/travis/berfarah/interactor-schema/master.svg?style=flat-square)](https://travis-ci.org/berfarah/interactor-schema)
+
+Interactor::Schema provides an enforcable Interactor Context via a `schema`
+class method.
+
+This gem was born out of frustration. In using Interactor, I often wouldn't know
+what methods would be defined on it. By forcing a schema upfront, and also
+requiring methods in Interactor classes, we bring order to
+`Interactor::Context`.
+
+## Installation
+
+Put this in your application's Gemfile:
+
+```ruby
+gem 'interactor'
+gem 'interactor-schema'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install interactor-schema
+
+## Usage
+
+See [here](https://github.com/collectiveidea/interactor) for the official
+Interactor documentation.
+
+
+### Setup
+
+When you include `Interactor::Schema`, you are able to define a schema for valid
+context methods using the `schema` DSL method.
+
+```rb
+class SaveUser
+  include Interactor::Schema
+  schema :name
+end
+```
+
+### Calling methods
+
+When the attribute is part of the valid schema, you will have no problems
+accessing it as usual:
+
+```rb
+context = SaveUser.call(name: "Bob")
+context.name
+# => "Bob"
+```
+
+For attributes outside the schema, you will get `NoMethodError`s. The same thing
+applies when trying to set an attribute outside of the schema.
+
+```rb
+context = SaveUser.call(age: 28)
+context.age
+# NoMethodError: undefined method 'age' for #<SaveUser:0x007f9521298b10>
+```
+
+### Use with Organizers
+
+`Interactor::Schema` works great with `Interactor::Organizer`s!
+
+```rb
+class SaveUser
+  include Interactor::Schema
+  include Interactor::Organizer
+
+  schema :name
+  organize ValidateInfo, SendMailer
+end
+
+class ValidateInfo
+  include Interactor
+
+  def call
+    # These will work, since name is in our schema
+    context.name
+    context.name = "Bob"
+
+    # These will fail with NoMethodErrors since age is not in our schema
+    context.age
+    context.age = 28
+  end
+end
+```
+
+The initial schema will be propagated through the entire chain, meaning no
+attributes outside of `name` can be set. This is particularly helpful for
+maintaining clarity of what information is being consumed by a chain of
+`Interactor`s.
+
+### Multiple Schemas
+
+In the case of multiple schemas being provided only the first one will be used
+(others will be discarded). The idea is that you should know upfront what
+attributes will be needed.
+
+Modifying the schema in the middle of the chain could result in confusing
+behavior.
+
+
+### Interactor Helper Methods
+
+This gem comes with two helper methods - one that should help enforce context
+cleanliness and one to delegate to the context.
+
+#### require_in_context
+
+`Interactor::require_in_context` ensures that the attributes provided as
+arguments are present and not `nil?` when the service is called.
+
+```rb
+class SaveUser
+  include Interactor
+  require_in_context :name
+end
+```
+
+This will fail:
+
+```rb
+SaveUser.call
+# => ArgumentError: Missing the following attributes in context: name
+```
+
+Whereas this will work:
+
+```rb
+SaveUser.call(name: "Bob")
+# => #<Interactor::Context:0x007f9521298b10>
+```
+
+#### delegate_to_context
+
+`Interactor::delegate_to_context` creates a method that delegates to the
+context.
+
+```rb
+class SaveUser
+  include Interactor
+
+  delegate_to_context :name
+
+  # is equivalent to:
+
+  def name
+    context.name
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/berfarah/interactor-schema.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "interactor/schema"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require "pry"
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/interactor-schema.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'interactor/schema/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "interactor-schema"
+  spec.version       = Interactor::Schema::VERSION
+  spec.authors       = ["Bernardo Farah"]
+  spec.email         = ["ber@bernardo.me"]
+
+  spec.summary       = "Enforce a schema with for Interactor Context"
+  spec.description   = "Interactor::Schema provides an enforcable Interactor Context"
+  spec.homepage      = "https://github.com/berfarah/interactor-schema"
+  spec.license       = "MIT"
+
+  spec.files      = `git ls-files`.split($/)
+  spec.test_files = spec.files.grep(/^spec/)
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "interactor", "~> 3.1"
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "pry", "~> 0.10"
+end

data/lib/interactor/schema.rb

@@ -0,0 +1,37 @@
+require "interactor"
+require "interactor/schema/context"
+require "interactor/schema/context_extension"
+require "interactor/schema/interactor_extension"
+require "interactor/schema/version"
+
+module Interactor
+  module Schema
+    # Internal: Install Interactor::Schema's behavior in the given class.
+    def self.included(base)
+      base.class_eval do
+        # Don't override methods when an Interactor has already been included
+        # For example, when Organizer has already been included
+        include Interactor unless base.ancestors.include? Interactor
+
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+
+    module ClassMethods
+      def schema(*method_names)
+        @schema = method_names.flatten
+      end
+
+      def _schema
+        @schema ||= []
+      end
+    end
+
+    module InstanceMethods
+      def initialize(context = {})
+        @context = Interactor::Schema::Context.build(context, self.class._schema)
+      end
+    end
+  end
+end

data/lib/interactor/schema/context.rb

@@ -0,0 +1,80 @@
+module Interactor
+  module Schema
+    class Context
+      def self.build(context = {}, schema = [])
+        self === context ? context : new(schema).tap do |instance|
+          instance.assign(context)
+        end
+      end
+
+      def initialize(schema = [])
+        @schema = schema
+        @table = {}
+        define_schema_methods(schema)
+      end
+
+      def [](key)
+        @table[key]
+      end
+
+      def assign(context)
+        filtered_context = context.select { |k, _| _schema.include?(k) }
+        @table.merge!(filtered_context)
+      end
+
+      def success?
+        !failure?
+      end
+
+      def failure?
+        @failure || false
+      end
+
+      def fail!(context = {})
+        @table.merge!(context)
+        @failure = true
+        raise Interactor::Failure, self
+      end
+
+      def called!(interactor)
+        _called << interactor
+      end
+
+      def rollback!
+        return false if @rolled_back
+        _called.reverse_each(&:rollback)
+        @rolled_back = true
+      end
+
+      def _called
+        @called ||= []
+      end
+
+      def _schema
+        @schema
+      end
+
+      def to_h
+        @table
+      end
+
+      private
+
+      attr_reader :table
+
+      def define_schema_methods(schema)
+        singleton_class.class_exec(schema) do |names|
+          names.each do |name|
+            define_method(name) do
+              @table[name]
+            end
+
+            define_method("#{name}=") do |value|
+              @table[name] = value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/interactor/schema/context_extension.rb

@@ -0,0 +1,10 @@
+module Interactor
+  class Context
+    # Overriding build method to continue with a Schema Context
+    # when one is found
+    def self.build(context = {})
+      return context if context.is_a?(Interactor::Schema::Context)
+      self === context ? context : new(context)
+    end
+  end
+end

data/lib/interactor/schema/interactor_extension.rb

@@ -0,0 +1,34 @@
+module Interactor
+  module ClassMethods
+    # Depends on Interactor::Hook
+    def require_in_context(*attributes)
+      before :require_in_context!
+      @required_in_context = attributes
+    end
+
+    def delegate_to_context(*attributes)
+      attributes.each do |attribute|
+        define_method(attribute) { context[attribute] }
+      end
+    end
+
+    attr_reader :required_in_context
+  end
+
+  private
+
+  def required_in_context
+    self.class.required_in_context
+  end
+
+  def require_in_context!
+    missing_attributes = required_in_context.select do |attribute|
+      context[attribute].nil?
+    end
+
+    return if missing_attributes.empty?
+    raise ArgumentError, <<-MESSAGE.strip
+      Missing the following attributes in context: #{missing_attributes.join(', ')}
+    MESSAGE
+  end
+end

data/lib/interactor/schema/version.rb

@@ -0,0 +1,5 @@
+module Interactor
+  module Schema
+    VERSION = "0.2.0"
+  end
+end

data/spec/interactor/schema/context_spec.rb

@@ -0,0 +1,210 @@
+module Interactor::Schema
+  describe Context do
+    describe ".build" do
+      it "doesn't respond to methods when no schema is given" do
+        context = Context.build(foo: "bar")
+
+        expect(context).to be_a(Context)
+        expect { context.foo }.to raise_error(NoMethodError)
+      end
+
+      it "responds to methods when a schema is given" do
+        context = Context.build({ foo: "bar" }, [:foo])
+
+        expect(context).to be_a(Context)
+        expect(context.foo).to eq("bar")
+      end
+
+      it "only responds to methods defined in the schema" do
+        context = Context.build({ foo: "bar" }, [:baz])
+
+        expect(context).to be_a(Context)
+        expect { context.foo }.to raise_error(NoMethodError)
+      end
+    end
+
+    describe "#_schema" do
+      let(:context) { Context.build({}, schema) }
+      let(:schema) { [:foo] }
+
+      it "is empty by default" do
+        context = Context.build
+        expect(context._schema).to eq([])
+      end
+
+      it "holds onto the schema" do
+        expect(context._schema).to eq(schema)
+      end
+    end
+
+    describe "#to_h" do
+      let(:context) { Context.build({ foo: "one", bar: "two" }, [:foo]) }
+      it "only records allowed values" do
+        expect(context.to_h).to eq(foo: "one")
+      end
+    end
+
+    # NOTE:
+    # The tests below are copied from the original Interactor::Context
+    # The only thing modified was to add the context argument where needed.
+    #
+    # You can find them here:
+    # https://github.com/collectiveidea/interactor/blob/master/spec/interactor/context_spec.rb
+    describe ".build" do
+      it "builds an empty context if no hash is given" do
+        context = Context.build
+
+        expect(context).to be_a(Context)
+        expect(context.send(:table)).to eq({})
+      end
+
+      it "doesn't affect the original hash" do
+        hash = { foo: "bar" }
+        context = Context.build(hash, [:foo])
+
+        expect(context).to be_a(Context)
+        expect {
+          context.foo = "baz"
+        }.not_to change {
+          hash[:foo]
+        }
+      end
+
+      it "preserves an already built context" do
+        context1 = Context.build({ foo: "bar" }, [:foo])
+        context2 = Context.build(context1)
+
+        expect(context2).to be_a(Context)
+        expect {
+          context2.foo = "baz"
+        }.to change {
+          context1.foo
+        }.from("bar").to("baz")
+      end
+    end
+
+    describe "#success?" do
+      let(:context) { Context.build }
+
+      it "is true by default" do
+        expect(context.success?).to eq(true)
+      end
+    end
+
+    describe "#failure?" do
+      let(:context) { Context.build }
+
+      it "is false by default" do
+        expect(context.failure?).to eq(false)
+      end
+    end
+
+    describe "#fail!" do
+      let(:context) { Context.build({ foo: "bar" }, [:foo]) }
+
+      it "sets success to false" do
+        expect {
+          context.fail! rescue nil
+        }.to change {
+          context.success?
+        }.from(true).to(false)
+      end
+
+      it "sets failure to true" do
+        expect {
+          context.fail! rescue nil
+        }.to change {
+          context.failure?
+        }.from(false).to(true)
+      end
+
+      it "preserves failure" do
+        context.fail! rescue nil
+
+        expect {
+          context.fail! rescue nil
+        }.not_to change {
+          context.failure?
+        }
+      end
+
+      it "preserves the context" do
+        expect {
+          context.fail! rescue nil
+        }.not_to change {
+          context.foo
+        }
+      end
+
+      it "updates the context" do
+        expect {
+          context.fail!(foo: "baz") rescue nil
+        }.to change {
+          context.foo
+        }.from("bar").to("baz")
+      end
+
+      it "raises failure" do
+        expect {
+          context.fail!
+        }.to raise_error(Interactor::Failure)
+      end
+
+      it "makes the context available from the failure" do
+        begin
+          context.fail!
+        rescue Interactor::Failure => error
+          expect(error.context).to eq(context)
+        end
+      end
+    end
+
+    describe "#called!" do
+      let(:context) { Context.build }
+      let(:instance1) { double(:instance1) }
+      let(:instance2) { double(:instance2) }
+
+      it "appends to the internal list of called instances" do
+        expect {
+          context.called!(instance1)
+          context.called!(instance2)
+        }.to change {
+          context._called
+        }.from([]).to([instance1, instance2])
+      end
+    end
+
+    describe "#rollback!" do
+      let(:context) { Context.build }
+      let(:instance1) { double(:instance1) }
+      let(:instance2) { double(:instance2) }
+
+      before do
+        allow(context).to receive(:_called) { [instance1, instance2] }
+      end
+
+      it "rolls back each instance in reverse order" do
+        expect(instance2).to receive(:rollback).once.with(no_args).ordered
+        expect(instance1).to receive(:rollback).once.with(no_args).ordered
+
+        context.rollback!
+      end
+
+      it "ignores subsequent attempts" do
+        expect(instance2).to receive(:rollback).once
+        expect(instance1).to receive(:rollback).once
+
+        context.rollback!
+        context.rollback!
+      end
+    end
+
+    describe "#_called" do
+      let(:context) { Context.build }
+
+      it "is empty by default" do
+        expect(context._called).to eq([])
+      end
+    end
+  end
+end

data/spec/interactor/schema/interactor_extension_spec.rb

@@ -0,0 +1,41 @@
+describe Interactor do
+  describe ".require_in_context" do
+    let(:interactor) do
+      Class.new do
+        include Interactor
+        require_in_context :foo
+      end
+    end
+
+    it "fails if the argument isn't passed in" do
+      expect { interactor.call }.to raise_error(ArgumentError)
+    end
+
+    it "fails if the argument is is nil" do
+      expect { interactor.call(foo: nil) }.to raise_error(ArgumentError)
+    end
+
+    it "succeeds if the argument is passed in" do
+      expect { interactor.call(foo: "bar") }.not_to raise_error
+    end
+  end
+
+  describe ".delegate_to_context" do
+    let(:interactor) do
+      Class.new do
+        include Interactor
+        delegate_to_context :foo
+
+        def call
+          foo
+        end
+      end
+    end
+    let(:context) { double("Context") }
+
+    it "delegates to the context" do
+      expect_any_instance_of(Interactor::Context).to receive(:[]).with(:foo).once
+      interactor.call
+    end
+  end
+end

data/spec/interactor/schema_spec.rb

@@ -0,0 +1,83 @@
+module Interactor
+  describe Schema do
+    include_examples :lint
+
+    describe ".schema" do
+      context "with an Interactor" do
+        let(:interactor) do
+          Class.new do
+            include Interactor
+            include Interactor::Schema
+
+            schema :foo
+          end
+        end
+        let(:context) { double(:context) }
+
+        it "s schema is passed to its context" do
+          expect(Interactor::Schema::Context).to receive(:build).once.with({ foo: "bar" }, [:foo]) { context }
+
+          instance = interactor.new(foo: "bar")
+
+          expect(instance).to be_a(interactor)
+          expect(instance.context).to eq(context)
+        end
+      end
+
+      context "with an Interactor::Organizer" do
+        let(:interactor1) do
+          Class.new do
+            include Interactor
+
+            def call
+              context.baz = "yolo"
+            end
+          end
+        end
+
+        let(:interactor2) do
+          Class.new.send(:include, Interactor)
+        end
+
+        let(:organizer) do
+          # Need to cache these for some reason
+          klass_1 = interactor1
+          klass_2 = interactor2
+
+          Class.new do
+            include Interactor::Organizer
+            include Interactor::Schema
+
+            schema :foo, :baz
+            organize klass_1, klass_2
+          end
+        end
+
+        it "passes around its context" do
+          context = organizer.call(foo: "bar")
+
+          expect(context.foo).to eq("bar")
+          expect(context.baz).to eq("yolo")
+        end
+
+        context "when assigning an attribute not available in the schema" do
+          let(:interactor2) do
+            Class.new do
+              include Interactor
+
+              def call
+                context.undefined = "hi"
+              end
+            end
+          end
+
+          it "raises a NoMethodError" do
+            expect {
+              organizer.call(foo: "bar")
+            }.to raise_error(NoMethodError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+# $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'interactor/schema'
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each { |f| require f }

data/spec/support/lint.rb

@@ -0,0 +1,138 @@
+# NOTE:
+# Copied directly from the official interactor repo:
+# https://github.com/collectiveidea/interactor/blob/master/spec/support/lint.rb
+shared_examples :lint do
+  let(:interactor) { Class.new.send(:include, described_class) }
+
+  describe ".call" do
+    let(:context) { double(:context) }
+    let(:instance) { double(:instance, context: context) }
+
+    it "calls an instance with the given context" do
+      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
+      expect(instance).to receive(:run).once.with(no_args)
+
+      expect(interactor.call(foo: "bar")).to eq(context)
+    end
+
+    it "provides a blank context if none is given" do
+      expect(interactor).to receive(:new).once.with({}) { instance }
+      expect(instance).to receive(:run).once.with(no_args)
+
+      expect(interactor.call).to eq(context)
+    end
+  end
+
+  describe ".call!" do
+    let(:context) { double(:context) }
+    let(:instance) { double(:instance, context: context) }
+
+    it "calls an instance with the given context" do
+      expect(interactor).to receive(:new).once.with(foo: "bar") { instance }
+      expect(instance).to receive(:run!).once.with(no_args)
+
+      expect(interactor.call!(foo: "bar")).to eq(context)
+    end
+
+    it "provides a blank context if none is given" do
+      expect(interactor).to receive(:new).once.with({}) { instance }
+      expect(instance).to receive(:run!).once.with(no_args)
+
+      expect(interactor.call!).to eq(context)
+    end
+  end
+
+  describe ".new" do
+    let(:context) { double(:context) }
+
+    it "initializes a context" do
+      expect(Interactor::Schema::Context).to receive(:build).once.with({ foo: "bar" }, []) { context }
+
+      instance = interactor.new(foo: "bar")
+
+      expect(instance).to be_a(interactor)
+      expect(instance.context).to eq(context)
+    end
+
+    it "initializes a blank context if none is given" do
+      expect(Interactor::Schema::Context).to receive(:build).once.with({}, []) { context }
+
+      instance = interactor.new
+
+      expect(instance).to be_a(interactor)
+      expect(instance.context).to eq(context)
+    end
+  end
+
+  describe "#run" do
+    let(:instance) { interactor.new }
+
+    it "runs the interactor" do
+      expect(instance).to receive(:run!).once.with(no_args)
+
+      instance.run
+    end
+
+    it "rescues failure" do
+      expect(instance).to receive(:run!).and_raise(Interactor::Failure)
+
+      expect {
+        instance.run
+      }.not_to raise_error
+    end
+
+    it "raises other errors" do
+      expect(instance).to receive(:run!).and_raise("foo")
+
+      expect {
+        instance.run
+      }.to raise_error("foo")
+    end
+  end
+
+  describe "#run!" do
+    let(:instance) { interactor.new }
+
+    it "calls the interactor" do
+      expect(instance).to receive(:call).once.with(no_args)
+
+      instance.run!
+    end
+
+    it "raises failure" do
+      expect(instance).to receive(:run!).and_raise(Interactor::Failure)
+
+      expect {
+        instance.run!
+      }.to raise_error(Interactor::Failure)
+    end
+
+    it "raises other errors" do
+      expect(instance).to receive(:run!).and_raise("foo")
+
+      expect {
+        instance.run
+      }.to raise_error("foo")
+    end
+  end
+
+  describe "#call" do
+    let(:instance) { interactor.new }
+
+    it "exists" do
+      expect(instance).to respond_to(:call)
+      expect { instance.call }.not_to raise_error
+      expect { instance.method(:call) }.not_to raise_error
+    end
+  end
+
+  describe "#rollback" do
+    let(:instance) { interactor.new }
+
+    it "exists" do
+      expect(instance).to respond_to(:rollback)
+      expect { instance.rollback }.not_to raise_error
+      expect { instance.method(:rollback) }.not_to raise_error
+    end
+  end
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: interactor-schema
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Bernardo Farah
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: interactor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+description: Interactor::Schema provides an enforcable Interactor Context
+email:
+- ber@bernardo.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- interactor-schema.gemspec
+- lib/interactor/schema.rb
+- lib/interactor/schema/context.rb
+- lib/interactor/schema/context_extension.rb
+- lib/interactor/schema/interactor_extension.rb
+- lib/interactor/schema/version.rb
+- spec/interactor/schema/context_spec.rb
+- spec/interactor/schema/interactor_extension_spec.rb
+- spec/interactor/schema_spec.rb
+- spec/spec_helper.rb
+- spec/support/lint.rb
+homepage: https://github.com/berfarah/interactor-schema
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Enforce a schema with for Interactor Context
+test_files:
+- spec/interactor/schema/context_spec.rb
+- spec/interactor/schema/interactor_extension_spec.rb
+- spec/interactor/schema_spec.rb
+- spec/spec_helper.rb
+- spec/support/lint.rb