duck_testing 0.0.1

data/spec/duck_testing/tester_spec.rb

@@ -0,0 +1,73 @@
+describe DuckTesting::Tester do
+  let(:tester) { described_class.new(*constract_param) }
+  let(:constract_param) { [receiver, method_name] }
+  let(:receiver) { nil }
+  let(:method_name) { nil }
+
+  shared_context "param matches to expected_types", match: true do
+    let(:param) { 1 }
+    let(:expected_types) do
+      [
+        DuckTesting::Type::ClassInstance.new(Fixnum),
+        DuckTesting::Type::ClassInstance.new(Float)
+      ]
+    end
+  end
+
+  shared_context "param does not match to expected_types", match: false do
+    let(:param) { 1 }
+    let(:expected_types) do
+      [DuckTesting::Type::ClassInstance.new(Float)]
+    end
+  end
+
+  describe "#test_param" do
+    subject { tester.test_param(param, expected_types) }
+
+    context "when param matches to expected_types", match: true do
+      it "does not raise error" do
+        expect { subject }.not_to raise_error
+      end
+    end
+
+    context "when param does not match to expected_types", match: false do
+      it "raise ContractViolationError" do
+        expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+        expect { subject }.to raise_error(/Contract violation for argument/)
+      end
+    end
+  end
+
+  describe "#test_return" do
+    subject { tester.test_return(param, expected_types) }
+
+    context "when param matches to expected_types", match: true do
+      it "does not raise error" do
+        expect { subject }.not_to raise_error
+      end
+
+      it "returns the given param" do
+        should eq param
+      end
+    end
+
+    context "when param does not match to expected_types", match: false do
+      it "raise ContractViolationError" do
+        expect { subject }.to raise_error(DuckTesting::ContractViolationError)
+        expect { subject }.to raise_error(/Contract violation for return value/)
+      end
+    end
+  end
+
+  describe "#match?" do
+    subject { tester.match?(param, expected_types) }
+
+    context "when param is a one of expected_types", match: true do
+      it { should be true }
+    end
+
+    context "when param is not a kind of expected_types", match: false do
+      it { should be false }
+    end
+  end
+end

data/spec/duck_testing/violation_spec.rb

@@ -0,0 +1,58 @@
+describe DuckTesting::Violation do
+  let(:violation) { described_class.new(params) }
+  let(:params) do
+    { call_data: call_data,
+      param: param,
+      expected_types: expected_types,
+      param_or_return: param_or_return }
+  end
+  let(:call_data) { nil }
+  let(:param) { nil }
+  let(:expected_types) { nil }
+  let(:param_or_return) { nil }
+
+  describe "#param?" do
+    subject { violation.param? }
+
+    context "when param_or_return is :param" do
+      let(:param_or_return) { :param }
+
+      it { should be true }
+    end
+
+    context "when param_or_return is :return" do
+      let(:param_or_return) { :return }
+
+      it { should be false }
+    end
+  end
+
+  describe "#return?" do
+    subject { violation.return? }
+
+    context "when param_or_return is :param" do
+      let(:param_or_return) { :param }
+
+      it { should be false }
+    end
+
+    context "when param_or_return is :return" do
+      let(:param_or_return) { :return }
+
+      it { should be true }
+    end
+  end
+
+  describe "#expected" do
+    subject { violation.expected }
+
+    let(:expected_types) do
+      [
+        DuckTesting::Type::ClassInstance.new(Fixnum),
+        DuckTesting::Type::ClassInstance.new(Float)
+      ]
+    end
+
+    it { should eq "Fixnum, Float" }
+  end
+end

data/spec/duck_testing/yard/builder_spec.rb

@@ -0,0 +1,179 @@
+describe DuckTesting::YARD::Builder do
+  describe "#build" do
+    subject { builder.build(scope) }
+    let(:builder) { described_class.new(class_object) }
+    let(:class_object) { DuckTesting::YARD::Parser.parse_string(content).first }
+    let(:params) { [] }
+
+    context "when scope parameter is :instance" do
+      before { klass.send(:prepend, subject) }
+      let(:contents) { "Hello, World" }
+      let(:instance) { klass.new }
+      let(:run) { instance.bar(*params) }
+      let(:scope) { :instance }
+
+      context "and return tag comment is given" do
+        let(:content) do
+          <<-EOF
+            class Foo
+              # @!method bar
+              #   @return [String]
+            end
+          EOF
+        end
+
+        context "and corresponding method returns valid type object" do
+          let(:klass) do
+            Class.new { def bar; "String" end }
+          end
+          it { expect { run }.not_to raise_error }
+        end
+
+        context "and corresponding method returns invalid type object" do
+          let(:klass) do
+            Class.new { def bar; :Symbol end }
+          end
+          it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+        end
+      end
+
+      context "and param tag comment is given" do
+        context "and there is a parameter without default value" do
+          let(:content) do
+            <<-EOF
+              class Foo
+                # @!method bar
+                #   @param name [String]
+              end
+            EOF
+          end
+          let(:klass) do
+            Class.new { def bar(_name) end }
+          end
+          context "and valid type object is given as the parameter" do
+            let(:params) { ["String"] }
+            it { expect { run }.not_to raise_error }
+          end
+
+          context "and invalid type object is given as the parameter" do
+            let(:params) { [:String] }
+            it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+          end
+        end
+
+        context "and there is a parameter with default value" do
+          let(:content) do
+            <<-EOF
+              class Foo
+                # @!method bar
+                #   @param name [String]
+              end
+            EOF
+          end
+          let(:klass) do
+            Class.new { def bar(_name = nil) end }
+          end
+
+          context "and the parameter is omitted" do
+            it { expect { run }.not_to raise_error }
+          end
+
+          context "and valid type object is given as the parameter" do
+            let(:params) { ["String"] }
+            it { expect { run }.not_to raise_error }
+          end
+
+          context "and invalid type object is given as the parameter" do
+            let(:params) { [:String] }
+            it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+          end
+        end
+
+        context "and there is a keyword parameter" do
+          let(:content) do
+            <<-EOF
+              class Foo
+                # @param key [String]
+                def bar(key: nil) end
+              end
+            EOF
+          end
+          let(:klass) do
+            Class.new { def bar(key: nil) end }
+          end
+
+          context "and valid type object is given as the parameter" do
+            let(:params) { [key: "String"] }
+            it { expect { run }.not_to raise_error }
+          end
+
+          context "and invalid type object is given as the parameter" do
+            let(:params) { [key: :Symbol] }
+            it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+          end
+        end
+
+        context "and there are both an normal paramter and a keyword parameter" do
+          let(:content) do
+            <<-EOF
+              class Foo
+                # @param name [String]
+                # @param key [String]
+                def bar(name, key: nil) end
+              end
+            EOF
+          end
+          let(:klass) do
+            Class.new { def bar(_name, key: nil) end }
+          end
+
+          context "and valid type objects are given as those parameters" do
+            let(:params) { ["String", key: "String"] }
+            it { expect { run }.not_to raise_error }
+          end
+
+          context "and invalid type object is given as the normal parameter" do
+            let(:params) { [:Symbol, key: "String"] }
+            it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+          end
+
+          context "and invalid type object is given as the keyword parameter" do
+            let(:params) { ["String", key: :Symbol] }
+            it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+          end
+        end
+      end
+    end
+
+    context "when scope parameter is :class" do
+      before { klass.singleton_class.send(:prepend, subject) }
+      let(:run) { klass.bar(*params) }
+      let(:scope) { :class }
+
+      context "and return tag comment is given" do
+        let(:content) do
+          <<-EOF
+            class Foo
+              # @!method self.bar
+              #   @return [String]
+            end
+          EOF
+        end
+
+        context "and corresponding method returns valid type object" do
+          let(:klass) do
+            Class.new { def self.bar; "String" end }
+          end
+          it { expect { run }.not_to raise_error }
+        end
+
+        context "and corresponding method returns invalid type object" do
+          let(:klass) do
+            Class.new { def self.bar; :Symbol end }
+          end
+          it { expect { run }.to raise_error(DuckTesting::ContractViolationError) }
+        end
+      end
+    end
+  end
+end

data/spec/duck_testing/yard/parser_spec.rb

@@ -0,0 +1,38 @@
+describe DuckTesting::YARD::Parser do
+  describe ".parse_string" do
+    subject { described_class.parse_string(content) }
+    let(:content) do
+      <<-EOF
+class Foo
+  # Reverses the contents of a String or IO object.
+  #
+  # @param [String, #read] contents the contents to reverse
+  # @return [String] the contents reversed lexically
+  def reverse(contents)
+    contents = contents.read if contents.respond_to? :read
+    contents.reverse
+  end
+end
+      EOF
+    end
+
+    it "returns an array of DuckTesting::YARD::ClassObject" do
+      should all be_a DuckTesting::YARD::ClassObject
+
+      class_object = subject.first
+      expect(class_object.path).to eq "Foo"
+      expect(class_object.method_objects).to all be_a DuckTesting::YARD::MethodObject
+
+      method_object = class_object.method_objects.first
+      expect(method_object.path).to eq "Foo#reverse"
+      expect(method_object.method_parameters).to all be_a DuckTesting::YARD::MethodParameter
+
+      method_parameter = method_object.method_parameters.first
+      expect(method_parameter.name).to eq "contents"
+      expect(method_parameter.parameter_tag.types).to eq ["String", "#read"]
+
+      return_tag = method_object.return_tag
+      expect(return_tag.types).to eq ["String"]
+    end
+  end
+end

data/spec/duck_type_integration_spec.rb

@@ -0,0 +1,89 @@
+require "stringio"
+
+describe "Duck type integration spec" do
+  subject do
+    instance.read(param)
+  end
+
+  before do
+    klass.send(:prepend, duck_testing_module)
+  end
+
+  let(:instance) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      # @param io [#read]
+      # @return [#read]
+      def read(io)
+        io
+      end
+    end
+  end
+
+  context "when expected parameter and return are given" do
+    let(:param) { StringIO.new }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def read(io)
+          tester = DuckTesting::Tester.new(self, "read")
+          tester.test_param(io, [
+            DuckTesting::Type::DuckType.new("read")
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::DuckType.new("read")
+          ])
+        end
+      end
+    end
+
+    it "does not raise error" do
+      expect { subject }.not_to raise_error
+    end
+
+    it "returns original result" do
+      should eq param
+    end
+  end
+
+  context "when unexpected parameter is given" do
+    let(:param) { "string" }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def read(io)
+          tester = DuckTesting::Tester.new(self, "read")
+          tester.test_param(io, [
+            DuckTesting::Type::DuckType.new("read")
+          ])
+        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) { "string" }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def read(io)
+          tester = DuckTesting::Tester.new(self, "read")
+          tester.test_return(super, [
+            DuckTesting::Type::DuckType.new("read")
+          ])
+        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/hash_type_integration_spec.rb

@@ -0,0 +1,112 @@
+describe "Hash type integration spec" do
+  subject do
+    instance.get(*params)
+  end
+
+  before do
+    klass.send(:prepend, duck_testing_module)
+  end
+
+  let(:instance) { klass.new }
+
+  let(:klass) do
+    Class.new do
+      # @param hash [Hash{Symbol => Object}]
+      # @param key [Symbol]
+      # @param default [Object]
+      # @return [Object]
+      def get(hash, key, default = nil)
+        hash.key?(key) ? hash[key] : default
+      end
+    end
+  end
+
+  context "when expected parameter and return are given" do
+    let(:params) { [{ a: 1, b: 2 }, :b, "hello"] }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def get(hash, key, default = nil)
+          tester = DuckTesting::Tester.new(self, "get")
+          tester.test_param(hash, [
+            DuckTesting::Type::Hash.new(
+              [DuckTesting::Type::ClassInstance.new(Symbol)],
+              [DuckTesting::Type::ClassInstance.new(Object)]
+            )
+          ])
+          tester.test_param(key, [
+            DuckTesting::Type::ClassInstance.new(Symbol)
+          ])
+          tester.test_param(default, [
+            DuckTesting::Type::ClassInstance.new(Object)
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::ClassInstance.new(Object)
+          ])
+        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(:params) { [{ "a" => 1 }, "a"] }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def get(hash, _key, _default = nil)
+          tester = DuckTesting::Tester.new(self, "get")
+          tester.test_param(hash, [
+            DuckTesting::Type::Hash.new(
+              [DuckTesting::Type::ClassInstance.new(Symbol)],
+              [DuckTesting::Type::ClassInstance.new(Object)]
+            )
+          ])
+        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(:params) { [{ a: 1, b: 2 }, :b, "hello"] }
+
+    let(:duck_testing_module) do
+      Module.new do
+        def get(hash, key, default = nil)
+          tester = DuckTesting::Tester.new(self, "get")
+          tester.test_param(hash, [
+            DuckTesting::Type::Hash.new(
+              [DuckTesting::Type::ClassInstance.new(Symbol)],
+              [DuckTesting::Type::ClassInstance.new(Object)]
+            )
+          ])
+          tester.test_param(key, [
+            DuckTesting::Type::ClassInstance.new(Symbol)
+          ])
+          tester.test_param(default, [
+            DuckTesting::Type::ClassInstance.new(Object)
+          ])
+          tester.test_return(super, [
+            DuckTesting::Type::ClassInstance.new(Symbol)
+          ])
+        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