entitlements 0.1.8 → 0.2.0

data/lib/contracts-ruby2/spec/methods_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe "Contracts:" do
+  describe "method called with blocks" do
+    module FuncTest
+      include Contracts::Core
+      include Contracts::Builtin
+
+      Contract Func[Num=>Num] => nil
+      def foo(&blk)
+        _ = blk.call(2)
+        nil
+      end
+
+      Contract Num, Func[Num=>Num] => nil
+      def foo2(a, &blk)
+        _ = blk.call(2)
+        nil
+      end
+
+      Contract Func[Num=>Num] => nil
+      def bar(blk)
+        _ = blk.call(2)
+        nil
+      end
+
+      Contract Num, Func[Num=>Num] => nil
+      def bar2(a, blk)
+        _ = blk.call(2)
+        nil
+      end
+    end
+
+    def obj
+      Object.new.tap do |o|
+        o.extend(FuncTest)
+      end
+    end
+
+    it "should enforce return value inside block with no other parameter" do
+      expect { obj.foo(&:to_s) }.to raise_error ReturnContractError
+    end
+
+    it "should enforce return value inside block with other parameter" do
+      expect { obj.foo2(2) { |x| x.to_s } }.to raise_error ReturnContractError
+    end
+
+    it "should enforce return value inside lambda with no other parameter" do
+      expect { obj.bar lambda { |x| x.to_s } }.to raise_error ReturnContractError
+    end
+
+    it "should enforce return value inside lambda with other parameter" do
+      expect { obj.bar2(2, lambda { |x| x.to_s }) }.to raise_error ReturnContractError
+    end
+  end
+end

data/lib/contracts-ruby2/spec/module_spec.rb

@@ -0,0 +1,18 @@
+module Mod
+  include Contracts::Core
+
+  Contract C::Num => C::Num
+  def self.a_module_method a
+    a + 1
+  end
+end
+
+RSpec.describe "module methods" do
+  it "should pass for correct input" do
+    expect { Mod.a_module_method(2) }.to_not raise_error
+  end
+
+  it "should fail for incorrect input" do
+    expect { Mod.a_module_method("bad") }.to raise_error(ContractError)
+  end
+end

data/lib/contracts-ruby2/spec/override_validators_spec.rb

@@ -0,0 +1,162 @@
+RSpec.describe Contract do
+  describe ".override_validator" do
+    around do |example|
+      Contract.reset_validators
+      example.run
+      Contract.reset_validators
+    end
+
+    it "allows to override simple validators" do
+      Contract.override_validator(Hash) do |contract|
+        lambda do |arg|
+          return false unless arg.is_a?(Hash)
+          # Any hash in my system should have :it_is_a_hash key!
+          return false unless arg.key?(:it_is_a_hash)
+          contract.keys.all? do |k|
+            Contract.valid?(arg[k], contract[k])
+          end
+        end
+      end
+
+      klass = Class.new do
+        include Contracts::Core
+
+        Contract ({ :a => Contracts::Num, :b => String }) => nil
+        def something(opts)
+          nil
+        end
+      end
+
+      obj = klass.new
+
+      expect do
+        obj.something(:a => 35, :b => "hello")
+      end.to raise_error(ContractError)
+
+      expect do
+        obj.something(
+          :a => 35,
+          :b => "hello",
+          :it_is_a_hash => true
+        )
+      end.not_to raise_error
+    end
+
+    it "allows to override valid contract" do
+      Contract.override_validator(:valid) do |contract|
+        if contract.respond_to?(:in_valid_state?)
+          lambda do |arg|
+            contract.in_valid_state? && contract.valid?(arg)
+          end
+        else
+          lambda { |arg| contract.valid?(arg) }
+        end
+      end
+
+      stateful_contract = Class.new(Contracts::CallableClass) do
+        def initialize(contract)
+          @contract = contract
+          @state = 0
+        end
+
+        def in_valid_state?
+          @state < 3
+        end
+
+        def valid?(arg)
+          @state += 1
+          Contract.valid?(arg, @contract)
+        end
+      end
+
+      klass = Class.new do
+        include Contracts::Core
+
+        Contract stateful_contract[Contracts::Num] => Contracts::Num
+        def only_three_times(x)
+          x * x
+        end
+      end
+
+      obj = klass.new
+
+      expect(obj.only_three_times(3)).to eq(9)
+      expect(obj.only_three_times(3)).to eq(9)
+      expect(obj.only_three_times(3)).to eq(9)
+
+      expect do
+        obj.only_three_times(3)
+      end.to raise_error(ContractError)
+
+      expect do
+        obj.only_three_times(3)
+      end.to raise_error(ContractError)
+    end
+
+    it "allows to override class validator" do
+      # Make contracts accept all rspec doubles
+      Contract.override_validator(:class) do |contract|
+        lambda do |arg|
+          arg.is_a?(RSpec::Mocks::Double) ||
+            arg.is_a?(contract)
+        end
+      end
+
+      klass = Class.new do
+        include Contracts::Core
+
+        Contract String => String
+        def greet(name)
+          "hello, #{name}"
+        end
+      end
+
+      obj = klass.new
+
+      expect(obj.greet("world")).to eq("hello, world")
+
+      expect do
+        obj.greet(4)
+      end.to raise_error(ContractError)
+
+      expect(obj.greet(double("name"))).to match(
+        /hello, #\[.*Double.*"name"\]/
+      )
+    end
+
+    it "allows to override default validator" do
+      spy = double("spy")
+
+      Contract.override_validator(:default) do |contract|
+        lambda do |arg|
+          spy.log("#{arg} == #{contract}")
+          arg == contract
+        end
+      end
+
+      klass = Class.new do
+        include Contracts::Core
+
+        Contract 1, Contracts::Num => Contracts::Num
+        def gcd(_, b)
+          b
+        end
+
+        Contract Contracts::Num, Contracts::Num => Contracts::Num
+        def gcd(a, b)
+          gcd(b % a, a)
+        end
+      end
+
+      obj = klass.new
+
+      expect(spy).to receive(:log).with("8 == 1").ordered.once
+      expect(spy).to receive(:log).with("5 == 1").ordered.once
+      expect(spy).to receive(:log).with("3 == 1").ordered.once
+      expect(spy).to receive(:log).with("2 == 1").ordered.once
+      expect(spy).to receive(:log).with("1 == 1").ordered.once
+
+      obj.gcd(8, 5)
+    end
+  end
+end

data/lib/contracts-ruby2/spec/ruby_version_specific/contracts_spec_1.9.rb

@@ -0,0 +1,24 @@
+class GenericExample
+  Contract C::Args[String], C::Num => C::ArrayOf[String]
+  def splat_then_arg(*vals, n)
+    vals.map { |v| v * n }
+  end
+
+  if ruby_version <= 1.9
+    Contract ({:foo => C::Nat}) => nil
+    def nat_test_with_kwarg(a_hash)
+    end
+  end
+end
+
+RSpec.describe "Contracts:" do
+  before :all do
+    @o = GenericExample.new
+  end
+
+  describe "Splat not last (or penultimate to block)" do
+    it "should work with arg after splat" do
+      expect { @o.splat_then_arg("hello", "world", 3) }.to_not raise_error
+    end
+  end
+end

data/lib/contracts-ruby2/spec/ruby_version_specific/contracts_spec_2.0.rb

@@ -0,0 +1,55 @@
+class GenericExample
+  Contract C::Args[String], { repeat: C::Maybe[C::Num] } => C::ArrayOf[String]
+  def splat_then_optional_named(*vals, repeat: 2)
+    vals.map { |v| v * repeat }
+  end
+
+  Contract ({foo: C::Nat}) => nil
+  def nat_test_with_kwarg(foo: 10)
+  end
+
+  Contract C::KeywordArgs[name: C::Optional[String]], C::Func[String => String] => String
+  def keyword_args_hello(name: "Adit", &block)
+    "Hey, #{yield name}!"
+  end
+end
+
+RSpec.describe "Contracts:" do
+  before :all do
+    @o = GenericExample.new
+  end
+
+  describe "Optional named arguments" do
+    it "should work with optional named argument unfilled after splat" do
+      expect { @o.splat_then_optional_named("hello", "world") }.to_not raise_error
+    end
+
+    it "should work with optional named argument filled after splat" do
+      expect { @o.splat_then_optional_named("hello", "world", repeat: 3) }.to_not raise_error
+    end
+  end
+
+  describe "Nat:" do
+    it "should pass for keyword args with correct arg given" do
+      expect { @o.nat_test_with_kwarg(foo: 10) }.to_not raise_error
+    end
+
+    it "should fail with a ContractError for wrong keyword args input" do
+      expect { @o.nat_test_with_kwarg(foo: -10) }.to raise_error(ContractError)
+    end
+
+    it "should fail with a ContractError for no input" do
+      expect { @o.nat_test_with_kwarg }.to raise_error(ContractError)
+    end
+  end
+
+  describe "keyword args with defaults, with a block" do
+    it "should work when both keyword args and a block is given" do
+      expect(@o.keyword_args_hello(name: "maggie", &:upcase)).to eq("Hey, MAGGIE!")
+    end
+
+    it "should work even when keyword args aren't given" do
+      expect(@o.keyword_args_hello(&:upcase)).to eq("Hey, ADIT!")
+    end
+  end
+end

data/lib/contracts-ruby2/spec/ruby_version_specific/contracts_spec_2.1.rb

@@ -0,0 +1,63 @@
+class GenericExample
+  Contract String, C::Bool, C::Args[Symbol], Float, C::KeywordArgs[e: Range, f: C::Optional[C::Num], g: Symbol], Proc =>
+           [Proc, Hash, C::Maybe[C::Num], Range, Float, C::ArrayOf[Symbol], C::Bool, String]
+  def complicated(a, b = true, *c, d, e:, f:2, **g, &h)
+    h.call [h, g, f, e, d, c, b, a]
+  end
+end
+
+RSpec.describe "Contracts:" do
+  before :all do
+    @o = GenericExample.new
+  end
+
+  describe "Required named arguments" do
+    describe "really complicated method signature" do
+      it "should work with default named args used" do
+        expect do
+          @o.complicated("a", false, :b, 2.0, e: (1..5), g: :d) { |x| x }
+        end.to_not raise_error
+      end
+
+      it "should work with all args filled manually, with extra splat and hash" do
+        expect do
+          @o.complicated("a", true, :b, :c, 2.0, e: (1..5), f: 8.3, g: :d) do |x|
+            x
+          end
+        end.to_not raise_error
+      end
+
+      it "should fail when the return is invalid" do
+        expect do
+          @o.complicated("a", true, :b, 2.0, e: (1..5)) { |_x| "bad" }
+        end.to raise_error(ContractError)
+      end
+
+      it "should fail when args are invalid" do
+        expect do
+          @o.complicated("a", "bad", :b, 2.0, e: (1..5)) { |x| x }
+        end.to raise_error(ContractError)
+      end
+
+      it "should fail when splat is invalid" do
+        expect do
+          @o.complicated("a", true, "bad", 2.0, e: (1..5)) { |x| x }
+        end.to raise_error(ContractError)
+      end
+
+      it "should fail when named argument is invalid" do
+        expect do
+          @o.complicated("a", true, :b, 2.0, e: "bad") { |x| x }
+        end.to raise_error(ContractError)
+      end
+
+      it "should fail when passed nil to an optional argument which contract shouldn't accept nil" do
+        expect do
+          @o.complicated("a", true, :b, :c, 2.0, e: (1..5), f: nil, g: :d) do |x|
+            x
+          end
+        end.to raise_error(ContractError, /Expected: \(KeywordArgs\[{:e=>Range, :f=>Optional\[Num\], :g=>Symbol}\]\)/)
+      end
+    end
+  end
+end

data/lib/contracts-ruby2/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require "contracts"
+require File.expand_path(File.join(__FILE__, "../support"))
+require File.expand_path(File.join(__FILE__, "../fixtures/fixtures"))
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.pattern = "*.rb"
+
+  # Only load tests who's syntax is valid in the current Ruby
+  [1.9, 2.0, 2.1].each do |ver|
+    config.pattern << ",ruby_version_specific/*#{ver}.rb" if ruby_version >= ver
+  end
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  # config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  # Unable to use it now
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # Callbacks
+  config.after :each do
+    ::Contract.restore_failure_callback
+  end
+end

data/lib/contracts-ruby2/spec/support.rb

@@ -0,0 +1,10 @@
+def with_enabled_no_contracts
+  no_contracts = ENV["NO_CONTRACTS"]
+  ENV["NO_CONTRACTS"] = "true"
+  yield
+  ENV["NO_CONTRACTS"] = no_contracts
+end
+
+def ruby_version
+  RUBY_VERSION.match(/\d+\.\d+/)[0].to_f
+end

data/lib/contracts-ruby2/spec/support_spec.rb

@@ -0,0 +1,21 @@
+module Contracts
+  RSpec.describe Support do
+    describe "eigenclass?" do
+      it "is falsey for non-singleton classes" do
+        expect(Contracts::Support.eigenclass? String).to be_falsey
+      end
+
+      it "is truthy for singleton classes" do
+        singleton_class = String.instance_exec { class << self; self; end }
+        expect(Contracts::Support.eigenclass? singleton_class).to be_truthy
+      end
+    end
+
+    describe "eigenclass_of" do
+      it "returns the eigenclass of a given object" do
+        singleton_class = String.instance_exec { class << self; self; end }
+        expect(Contracts::Support.eigenclass_of String).to eq singleton_class
+      end
+    end
+  end
+end

data/lib/contracts-ruby2/spec/validators_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+RSpec.describe "Contract validators" do
+  subject(:o) { GenericExample.new }
+
+  describe "Range" do
+    it "passes when value is in range" do
+      expect do
+        o.method_with_range_contract(5)
+      end.not_to raise_error
+    end
+
+    it "fails when value is not in range" do
+      expect do
+        o.method_with_range_contract(300)
+      end.to raise_error(ContractError, /Expected: 1\.\.10/)
+    end
+
+    it "fails when value is incorrect" do
+      expect do
+        o.method_with_range_contract("hello world")
+      end.to raise_error(ContractError, /Expected: 1\.\.10.*Actual: "hello world"/m)
+    end
+  end
+
+  describe "Regexp" do
+    it "should pass for a matching string" do
+      expect { o.should_contain_foo("containing foo") }.to_not raise_error
+    end
+
+    it "should fail for a non-matching string" do
+      expect { o.should_contain_foo("that's not F00") }.to raise_error(ContractError)
+    end
+
+    describe "within a hash" do
+      it "should pass for a matching string" do
+        expect { o.hash_containing_foo(:host => "foo.example.org") }.to_not raise_error
+      end
+    end
+
+    describe "within an array" do
+      it "should pass for a matching string" do
+        expect { o.array_containing_foo(["foo"]) }.to_not raise_error
+      end
+    end
+  end
+end