duck_testing 0.0.1

data/lib/duck_testing/yard/method_parameter.rb

@@ -0,0 +1,49 @@
+module DuckTesting
+  module YARD
+    class MethodParameter
+      attr_reader :method_object, :name, :default, :parameter_tag
+
+      # @param method_object [DuckTesting::YARD::MethodObject]
+      # @param name [String]
+      # @param default [String]
+      # @param parameter_tag [YARD::Tags::Tag]
+      def initialize(method_object, name, default, parameter_tag)
+        @method_object = method_object
+        @name = name
+        @default = default
+        @parameter_tag = parameter_tag
+      end
+
+      # @return [String]
+      def to_s
+        if default.nil?
+          name
+        elsif name.end_with?(":")
+          "#{name} #{default}"
+        else
+          "#{name} = #{default}"
+        end
+      end
+
+      # @return [Boolean]
+      def documented?
+        !parameter_tag.nil?
+      end
+
+      # @return [Boolean]
+      def keyword?
+        name.end_with?(":")
+      end
+
+      # @return [Symbol, nil]
+      def key_name
+        keyword? ? name[0...-1].to_sym : nil
+      end
+
+      # @return [Array<DuckTesting::Type::Base>]
+      def expected_types
+        parameter_tag ? DuckTesting::YARD.expected_types(parameter_tag.types) : []
+      end
+    end
+  end
+end

data/lib/duck_testing/yard/parser.rb

@@ -0,0 +1,30 @@
+require "yard"
+
+module DuckTesting
+  module YARD
+    class Parser
+      class << self
+        # Parses a path or set of paths.
+        #
+        # @param paths [String, Array<String>] a path, glob or list of paths to parse
+        # @param excluded [Array<String, Regexp>] a list of excluded path matchers
+        # @return [Array<DuckTesting::YARD::ClassObject>]
+        def parse(paths, excluded)
+          ::YARD::Registry.clear
+          ::YARD::Parser::SourceParser.parse(paths, excluded)
+          ::YARD::Registry.all(:class).map { |class_object| ClassObject.new(class_object) }
+        end
+
+        # Parses a string `content`.
+        #
+        # @param content [String] the block of code to parse.
+        # @return [Array<DuckTesting::YARD::ClassObject>]
+        def parse_string(content)
+          ::YARD::Registry.clear
+          ::YARD::Parser::SourceParser.parse_string(content)
+          ::YARD::Registry.all(:class).map { |class_object| ClassObject.new(class_object) }
+        end
+      end
+    end
+  end
+end

data/sample/.gitignore

@@ -0,0 +1,35 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+spec/examples.txt

data/sample/.rspec

@@ -0,0 +1,3 @@
+--colour
+--format doc
+--require spec_helper

data/sample/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "duck_testing", path: "../"
+gem "pry"
+gem "rspec", "~> 3.3"

data/sample/lib/concern.rb

@@ -0,0 +1,9 @@
+module Concern
+  # Calculate `number` multiplied by 2.
+  #
+  # @param number [Integer] the integer number to be doubled.
+  # @return [Integer] the doubled integer.
+  def double(number)
+    number * 2
+  end
+end

data/sample/lib/sample.rb

@@ -0,0 +1,14 @@
+require "concern"
+
+class Sample
+  include Concern
+
+  # Duplicate some text an arbitrary number of times.
+  #
+  # @param text [String] the string to be duplicated.
+  # @param count [Integer] the integer number of times to duplicate the `text`.
+  # @return [String] the duplicated string.
+  def multiplex(text, count)
+    text * count
+  end
+end

data/sample/spec/sample_spec.rb

@@ -0,0 +1,33 @@
+describe Sample do
+  let(:sample) { described_class.new }
+
+  describe "#multiplex" do
+    subject { sample.multiplex(text, count) }
+
+    context "when valid parameters are given" do
+      let(:text) { "sample" }
+      let(:count) { 3 }
+      it { should eq "samplesamplesample" }
+    end
+
+    context "when invalid parameters are given" do
+      let(:text) { 3 }
+      let(:count) { 3 }
+      it { expect { subject }.to raise_error(DuckTesting::ContractViolationError) }
+    end
+  end
+
+  describe "#double" do
+    subject { sample.double(number) }
+
+    context "when valid parameters are given" do
+      let(:number) { 3 }
+      it { should eq 6 }
+    end
+
+    context "when invalid parameters are given" do
+      let(:number) { "sample" }
+      it { expect { subject }.to raise_error(DuckTesting::ContractViolationError) }
+    end
+  end
+end

data/sample/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "sample"
+require "duck_testing"
+
+DuckTesting::YARD.apply

data/spec/.rubocop.yml

@@ -0,0 +1,8 @@
+inherit_from:
+  - ../.rubocop.yml
+
+Metrics/MethodLength:
+  Enabled: false
+
+Style/SingleLineMethods:
+  Enabled: false

data/spec/class_type_integration_spec.rb

@@ -0,0 +1,98 @@
+describe "Integration spec" do
+  subject do
+    instance.double(param)
+  end
+
+  before do
+    klass.send(:prepend, duck_testing_module)
+  end
+
+  let(:instance) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      # @param number [Fixnum, Float]
+      # @return [Fixnum, Float]
+      def double(number)
+        number * 2
+      end
+    end
+  end
+
+  context "when expected parameter and return are given" do
+    let(:param) { 1 }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def double(number)
+          tester = DuckTesting::Tester.new(self, "double")
+          tester.test_param(number, [
+            DuckTesting::Type::ClassInstance.new(Fixnum),
+            DuckTesting::Type::ClassInstance.new(Float)
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::ClassInstance.new(Fixnum),
+            DuckTesting::Type::ClassInstance.new(Float)
+          ])
+        end
+      end
+    end
+
+    it "does not raise error" do
+      expect { subject }.not_to raise_error
+    end
+
+    it "returns original result" do
+      should eq 2
+    end
+  end
+
+  context "when unexpected parameter is given" do
+    let(:param) { "string" }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def double(number)
+          tester = DuckTesting::Tester.new(self, "double")
+          tester.test_param(number, [
+            DuckTesting::Type::ClassInstance.new(Fixnum),
+            DuckTesting::Type::ClassInstance.new(Float)
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::ClassInstance.new(Fixnum),
+            DuckTesting::Type::ClassInstance.new(Float)
+          ])
+        end
+      end
+    end
+
+    it "raises ContractViolationError" do
+      expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+      expect { subject }.to raise_error(/Contract violation for argument/)
+    end
+  end
+
+  context "when unexpected result is given" do
+    let(:param) { 1 }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def double(number)
+          tester = DuckTesting::Tester.new(self, "double")
+          tester.test_param(number, [
+            DuckTesting::Type::ClassInstance.new(Fixnum),
+            DuckTesting::Type::ClassInstance.new(Float)
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::ClassInstance.new(String)
+          ])
+        end
+      end
+    end
+
+    it "raises ContractViolationError" do
+      expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+      expect { subject }.to raise_error(/Contract violation for return value/)
+    end
+  end
+end

data/spec/constant_type_integration_spec.rb

@@ -0,0 +1,90 @@
+describe "Constant type integration spec" do
+  subject do
+    instance.not(param)
+  end
+
+  before do
+    klass.send(:prepend, duck_testing_module)
+  end
+
+  let(:instance) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      # @param a [Boolean]
+      # @return [Boolean]
+      def not(a)
+        !a
+      end
+    end
+  end
+
+  context "when expected parameter and return are given" do
+    let(:param) { true }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def not(a)
+          tester = DuckTesting::Tester.new(self, "not")
+          tester.test_param(a, [
+            DuckTesting::Type::Constant.new(true),
+            DuckTesting::Type::Constant.new(false)
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::Constant.new(true),
+            DuckTesting::Type::Constant.new(false)
+          ])
+        end
+      end
+    end
+
+    it "does not raise error" do
+      expect { subject }.not_to raise_error
+    end
+
+    it "returns original result" do
+      should eq false
+    end
+  end
+
+  context "when unexpected parameter is given" do
+    let(:param) { "string" }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def not(a)
+          tester = DuckTesting::Tester.new(self, "not")
+          tester.test_param(a, [
+            DuckTesting::Type::Constant.new(true),
+            DuckTesting::Type::Constant.new(false)
+          ])
+        end
+      end
+    end
+
+    it "raises ContractViolationError" do
+      expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+      expect { subject }.to raise_error(/Contract violation for argument/)
+    end
+  end
+
+  context "when unexpected result is given" do
+    let(:param) { true }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def not(a)
+          tester = DuckTesting::Tester.new(self, "not")
+          tester.test_return(super, [
+            DuckTesting::Type::Constant.new(true)
+          ])
+        end
+      end
+    end
+
+    it "raises ContractViolationError" do
+      expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+      expect { subject }.to raise_error(/Contract violation for return value/)
+    end
+  end
+end

data/spec/duck_testing/method_call_data_spec.rb

@@ -0,0 +1,24 @@
+describe DuckTesting::MethodCallData do
+  let(:call_data) { described_class.new(*params) }
+  let(:params) { [receiver, method_name] }
+  let(:receiver) { nil }
+  let(:method_name) { nil }
+
+  describe "#method_expr" do
+    subject { call_data.method_expr }
+
+    let(:klass) do
+      Class.new do
+        def self.name
+          "Foo::Bar"
+        end
+      end
+    end
+    let(:receiver) { klass.new }
+    let(:method_name) { "method_name" }
+
+    it 'returns "Class#method" style method name' do
+      should eq "#{klass.name}##{method_name}"
+    end
+  end
+end

data/spec/duck_testing/reporter/raise_error_spec.rb

@@ -0,0 +1,35 @@
+describe DuckTesting::Reporter::RaiseError do
+  let(:reporter) { described_class.new(violation) }
+  let(:violation) { DuckTesting::Violation.new(violation_param) }
+  let(:violation_param) do
+    { call_data: call_data,
+      expected_types: [] }
+  end
+  let(:call_data) { DuckTesting::MethodCallData.new("receiver", "mehtod_name") }
+
+  describe "#report" do
+    subject { reporter.report }
+
+    context "when violation#param? is true" do
+      before do
+        allow(violation).to receive(:param?).and_return(true)
+      end
+
+      it "raise ContractViolationError" do
+        expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+        expect { subject }.to raise_error(/Contract violation for argument/)
+      end
+    end
+
+    context "when violation#return? is true" do
+      before do
+        allow(violation).to receive(:return?).and_return(true)
+      end
+
+      it "raise ContractViolationError" do
+        expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+        expect { subject }.to raise_error(/Contract violation for return value/)
+      end
+    end
+  end
+end