rspec-twirp 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5fd6d0300d49b6797b5e346b3c9091dc946a7dde949aeebe8a188ece2a68ed24
-  data.tar.gz: 634c8748918a04c36a576bcfc377fcfa122d01f3b58d4b5a7576098a11e882d9
+  metadata.gz: c2f0ca51df29824ba1c1f2d1944ca94119501b3ec6366d09144f077bd99c92f2
+  data.tar.gz: 513bdae144ce76ecec652954cff14d3f8467037f6ec706ab67181be0ac036d61
 SHA512:
-  metadata.gz: 7a2cb6d3d9d72219a255d03905f8007dec32263f938067c27986a308542fbe953ff372e8adb6a841b86f498d6d66c32a065a7b550eaf85a771a06792367daca0
-  data.tar.gz: 6f748768287f63658564c30ebff9bc6ef1bbb7965bc3236f9af5dd52c1e1ae01b5e41001f349a7510d763e8f2401824b358f89cdc3fb8c8f6b19688965991d49
+  metadata.gz: 4a4ebdce6d3d96826eca31484d1d4c22dc5b9e07fb109bea659315c5cfc7265f497f8d0a0bb498115e654ee139b232d6c6eb74bfd6da03a325a44411e636486c
+  data.tar.gz: 4342593db5f6e34db3fb0c3829a04ff1b8bc5806960e6b0efb144f650c38b80b08559b7f1f1a616a1c36712e2fb4a1c9cb963e457accd9451ac1ad3a6314096f

data/lib/rspec/twirp/client_response_matcher.rb

@@ -0,0 +1,48 @@
+RSpec::Matchers.define :be_a_twirp_client_response do |type = nil, **attrs|
+  chain :with_error do |*matchers, **meta_matchers|
+    # code, msg, meta
+    @with_error = [ matchers, meta_matchers ]
+  end
+
+  match do |actual|
+    # ensure type is a valid twirp request type
+    if type && !(type < Google::Protobuf::MessageExts)
+      raise ArgumentError, "Expected `type` to be a Twirp response, found: #{type}"
+    end
+
+    @fail_msg = "Expected a Twirp::ClientResp, found #{actual}"
+    return false unless actual.is_a?(Twirp::ClientResp)
+
+    # match expected response type
+    @fail_msg = "Expected a Twirp::ClientResp of type #{type}, found #{actual.data&.class}"
+    return false if type && actual.data&.class != type
+
+    if @with_error
+      unless attrs.empty?
+        raise ArgumentError, "match data attributes or error, but not both"
+      end
+
+      @fail_msg = "Expected #{actual} to have an error"
+      return false unless actual.error
+
+      matchers, meta_matchers = @with_error
+      expect(actual.error).to be_a_twirp_error(*matchers, **meta_matchers)
+    else
+      @fail_msg = "Expected #{actual} to have data"
+      return false unless actual.data
+
+      expect(actual.data).to be_a_twirp_response(**attrs)
+    end
+  rescue RSpec::Expectations::ExpectationNotMetError => err
+    @fail_msg = err.message
+    false
+  end
+
+  description do
+    type ? "a #{type} Twirp response" : "a Twirp response"
+  end
+
+  failure_message { @fail_msg }
+end
+
+RSpec::Matchers.alias_matcher :a_twirp_client_response, :be_a_twirp_client_response

data/lib/rspec/twirp/error_matcher.rb

@@ -0,0 +1,49 @@
+RSpec::Matchers.define :be_a_twirp_error do |*matchers, **meta_matcher|
+  match do |actual|
+    @fail_msg = "Expected #{actual} to be a Twirp::Error, found #{actual.class}"
+    return false unless actual.is_a?(Twirp::Error)
+
+    matchers.each do |matcher|
+      case matcher
+      when Symbol
+        # match code
+
+        unless Twirp::Error.valid_code?(matcher)
+          raise ArgumentError, "invalid error code: #{matcher.inspect}"
+        end
+
+        @fail_msg = "Expected #{actual} to have code: #{matcher.inspect}, found #{actual.code}"
+        return false unless actual.code == matcher
+      else
+        # match msg
+
+        @fail_msg = "Expected #{actual} to have msg: #{matcher.inspect}, found #{actual.msg}"
+        return false unless values_match?(matcher, actual.msg)
+      end
+    end
+
+    # match meta
+    unless meta_matcher.empty?
+      @cur_match = { meta: meta_matcher }
+
+      # sanity check...values must be Strings or Regexp
+      discrete_attrs = meta_matcher.transform_values do |attr|
+        attr.is_a?(Regexp) ? attr.inspect : attr
+      end
+      actual.send(:validate_meta, discrete_attrs)
+
+      @fail_msg = "Expected #{actual} to have meta: #{meta_matcher.inspect}, found #{actual.meta}"
+      return false unless values_match?(meta_matcher, actual.meta)
+    end
+
+    true
+  end
+
+  description do
+    "a Twirp::Error"
+  end
+
+  failure_message { @fail_msg }
+end
+
+RSpec::Matchers.alias_matcher :a_twirp_error, :be_a_twirp_error

data/lib/rspec/twirp/request_matcher.rb

@@ -0,0 +1,37 @@
+RSpec::Matchers.define :be_a_twirp_request do |type = nil, **attrs|
+  match do |actual|
+    # ensure type is a valid twirp request type
+    if type && !(type < Google::Protobuf::MessageExts)
+      raise ArgumentError, "Expected `type` to be a Twirp request, found: #{type}"
+    end
+
+    @fail_msg = "Expected a Twirp request, found #{actual}"
+    return false unless actual.is_a?(Google::Protobuf::MessageExts)
+
+    # match expected request type
+    @fail_msg = "Expected a Twirp request of type #{type}, found #{actual.class}"
+    return false if type && actual.class != type
+
+    return true if attrs.empty?
+
+    RSpec::Twirp.validate_types(attrs, actual.class)
+
+    # match attributes which are present
+    attrs.each do |attr_name, expected_attr|
+      actual_attr = actual.send(attr_name)
+
+      @fail_msg = "Expected #{actual} to have #{attr_name}: #{expected_attr.inspect}, found #{actual_attr}"
+      return false unless values_match?(expected_attr, actual_attr)
+    end
+
+    true
+  end
+
+  description do
+    type ? "a #{type} Twirp request" : "a Twirp request"
+  end
+
+  failure_message { @fail_msg }
+end
+
+RSpec::Matchers.alias_matcher :a_twirp_request, :be_a_twirp_request

data/lib/rspec/twirp/response_matcher.rb

@@ -0,0 +1,37 @@
+RSpec::Matchers.define :be_a_twirp_response do |type = nil, **attrs|
+  match do |actual|
+    # ensure type is a valid twirp response type
+    if type && !(type < Google::Protobuf::MessageExts)
+      raise ArgumentError, "Expected `type` to be a Twirp response, found: #{type}"
+    end
+
+    @fail_msg = "Expected a Twirp response, found #{actual}"
+    return false unless actual.is_a?(Google::Protobuf::MessageExts)
+
+    # match expected response type
+    @fail_msg = "Expected a Twirp response of type #{type}, found #{actual.class}"
+    return false if type && actual.class != type
+
+    return true if attrs.empty?
+
+    RSpec::Twirp.validate_types(attrs, actual.class)
+
+    # match attributes which are present
+    attrs.each do |attr_name, expected_attr|
+      actual_attr = actual.send(attr_name)
+
+      @fail_msg = "Expected #{actual} to have #{attr_name}: #{expected_attr.inspect}, found #{actual_attr}"
+      return false unless values_match?(expected_attr, actual_attr)
+    end
+
+    true
+  end
+
+  description do
+    type ? "a #{type} Twirp response" : "a Twirp response"
+  end
+
+  failure_message { @fail_msg }
+end
+
+RSpec::Matchers.alias_matcher :a_twirp_response, :be_a_twirp_response

data/lib/rspec/twirp/version.rb

@@ -0,0 +1,5 @@
+module RSpec
+  module Twirp
+    VERSION = "0.1.0"
+  end
+end

data/lib/rspec/twirp.rb

@@ -0,0 +1,32 @@
+require "rspec/expectations"
+require "rspec/twirp/client_response_matcher"
+require "rspec/twirp/error_matcher"
+require "rspec/twirp/request_matcher"
+require "rspec/twirp/response_matcher"
+
+module RSpec
+  module Twirp
+    extend self
+
+    def validate_types(attrs, klass)
+      # sanity check type and names of attrs by constructing an actual
+      # proto object
+      discrete_attrs = attrs.transform_values do |attr|
+        case attr
+        when Regexp
+          attr.inspect
+        when Range
+          attr.first
+        when RSpec::Matchers::BuiltIn::BaseMatcher
+          nil
+        else
+          attr
+        end
+      end.compact
+
+      klass.new(**discrete_attrs)
+    rescue Google::Protobuf::TypeError => e
+      raise TypeError, e.message
+    end
+  end
+end

data/lib/rspec-twirp.rb

@@ -1,5 +1 @@
-require "rspec-twirp/version"
-
-module RSpecTwirp
-
-end
+require "rspec/twirp"

data/spec/client_response_spec.rb

@@ -0,0 +1,112 @@
+describe "be_a_twirp_client_response" do
+  context "with a response" do
+    subject { Twirp::ClientResp.new(GoodbyeResponse.new, nil) }
+
+    it { is_expected.to be_a_twirp_client_response }
+
+    it "catches non-twirp response" do
+      expect {
+        expect(Object).to be_a_twirp_client_response
+      }.to fail_with /found Object/
+    end
+
+    it "matches a specific response type" do
+      is_expected.to be_a_twirp_client_response(GoodbyeResponse)
+    end
+
+    it "catches type mismatches" do
+      expect {
+        is_expected.to be_a_twirp_client_response(HelloResponse)
+      }.to fail_with /of type HelloResponse/
+    end
+
+    it "catches erroneous response types" do
+      expect {
+        is_expected.to be_a_twirp_client_response(Object)
+      }.to raise_error(ArgumentError, /Object/)
+    end
+
+    context "with attributes" do
+      subject { Twirp::ClientResp.new(GoodbyeResponse.new(**attrs), nil) }
+
+      let(:attrs) { { message: "bye", name: "Bob" } }
+
+      it "can match attributes" do
+        is_expected.to be_a_twirp_client_response(GoodbyeResponse, **attrs)
+      end
+
+      it "supports regex matches" do
+        is_expected.to be_a_twirp_client_response(name: /^B/)
+      end
+
+      it "catches mismatches" do
+        expect {
+          is_expected.to be_a_twirp_client_response(name: "nope")
+        }.to fail_with /to have name: "nope"/
+
+        expect {
+          is_expected.to be_a_twirp_client_response(name: /no/)
+        }.to fail_with /to have name: \/no\//
+      end
+
+      it "catches the erroneous attributes" do
+        expect {
+          is_expected.to be_a_twirp_client_response(namezzz: "Bob")
+        }.to raise_error(ArgumentError, /namezzz/)
+      end
+
+      it "catches type mismatches" do
+        expect {
+          is_expected.to be_a_twirp_client_response(name: 123)
+        }.to raise_error(TypeError, /string field.*given Integer/)
+      end
+    end
+  end
+
+  context "with error" do
+    subject { Twirp::ClientResp.new(nil, error) }
+
+    let(:error) { Twirp::Error.new(code, msg, meta) }
+    let(:code) { :not_found }
+    let(:msg) { "Not Found" }
+    let(:meta) { { is_meta: "true" } }
+
+    it { is_expected.to be_a_twirp_client_response.with_error }
+    it { is_expected.to be_a_twirp_client_response.with_error(code) }
+    it { is_expected.to be_a_twirp_client_response.with_error(msg) }
+    it { is_expected.to be_a_twirp_client_response.with_error(**meta) }
+    it { is_expected.to be_a_twirp_client_response.with_error(/Not/) }
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_client_response.with_error(:internal)
+      }.to fail_with /code: :internal/
+    end
+  end
+
+  context "with neither response nor error" do
+    subject { Twirp::ClientResp.new(nil, nil) }
+
+    it "fails the response match" do
+      expect {
+        is_expected.to be_a_twirp_client_response
+      }.to fail_with /to have data/
+    end
+
+    it "fails the error match" do
+      expect {
+        is_expected.to be_a_twirp_client_response.with_error
+      }.to fail_with /to have an error/
+    end
+  end
+
+  context "with both response and error" do
+    subject { Twirp::ClientResp.new(GoodbyeResponse.new, Twirp::Error.not_found("Not Found")) }
+
+    it "fails" do
+      expect {
+        is_expected.to be_a_twirp_client_response(name: "Bob").with_error
+      }.to raise_error(ArgumentError, /but not both/)
+    end
+  end
+end

data/spec/error_spec.rb

@@ -0,0 +1,86 @@
+describe "be_a_twirp_error" do
+  subject { Twirp::Error.new(code, msg, meta) }
+
+  let(:code) { :not_found }
+  let(:msg) { "Not Found" }
+  let(:meta) { { is_meta: "true" } }
+
+  it { is_expected.to be_a_twirp_error }
+
+  it "catches type mismatches" do
+    expect {
+      expect(Object).to be_a_twirp_error
+    }.to fail_with /to be a Twirp::Error/
+  end
+
+  describe "code matches" do
+    it { is_expected.to be_a_twirp_error(:not_found) }
+
+    it { expect { is_expected.to be_a_twirp_error(:unknown) }.to fail }
+
+    it "catches erroneous codes" do
+      expect {
+        is_expected.to be_a_twirp_error(:not_a_valid_code)
+      }.to raise_error(ArgumentError, /:not_a_valid_code/)
+    end
+  end
+
+  describe "msg matches" do
+    it { is_expected.to be_a_twirp_error("Not Found") }
+
+    it "supports Regex matches" do
+      is_expected.to be_a_twirp_error(/Not/)
+    end
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error("Not")
+      }.to fail_with /to have msg: "Not"/
+
+      expect {
+        is_expected.to be_a_twirp_error(/Nope/)
+      }.to fail_with /to have msg: \/Nope\//
+    end
+  end
+
+  describe "meta matches" do
+    it { is_expected.to be_a_twirp_error(is_meta: "true") }
+    it { is_expected.to be_a_twirp_error(is_meta: /^t/) }
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error(is_meta: "false")
+      }.to fail_with /to have meta.*is_meta/
+
+      expect {
+        is_expected.to be_a_twirp_error(not_meta: "")
+      }.to fail_with /to have meta.*not_meta/
+    end
+
+    it "catches type errors" do
+      expect {
+        is_expected.to be_a_twirp_error(is_meta: true)
+      }.to raise_error(ArgumentError, /meta values must be Strings/)
+    end
+  end
+
+  describe "multi matches" do
+    it { is_expected.to be_a_twirp_error(:not_found, "Not Found") }
+    it { is_expected.to be_a_twirp_error(:not_found, /Not/) }
+    it { is_expected.to be_a_twirp_error(:not_found, is_meta: "true") }
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_error(:unknown, "Not Found")
+      }.to fail_with /unknown/
+
+      expect {
+        is_expected.to be_a_twirp_error(:not_found, "Nope")
+      }.to fail_with /Nope/
+
+      expect {
+        is_expected.to be_a_twirp_error(:not_found, is_meta: "false")
+      }.to fail_with /false/
+    end
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,75 @@
+describe "be_a_twirp_request" do
+  subject { HelloRequest.new(**attrs) }
+
+  let(:attrs) { {} }
+
+  it { is_expected.to be_a_twirp_request }
+
+  it "catches non-twirp requests" do
+    expect {
+      expect(Object).to be_a_twirp_request
+    }.to fail_with /Expected a Twirp request, found Object/
+  end
+
+  it "matches a specific request type" do
+    is_expected.to be_a_twirp_request(HelloRequest)
+  end
+
+  it "catches type mismatches" do
+    expect {
+      is_expected.to be_a_twirp_request(GoodbyeRequest)
+    }.to fail_with /request of type GoodbyeRequest/
+  end
+
+  it "catches erroneous request types" do
+    expect {
+      is_expected.to be_a_twirp_request(Object)
+    }.to raise_error(ArgumentError, /Object/)
+  end
+
+  context "with attributes" do
+    let(:attrs) { { name: "Bob", count: 3 } }
+
+    it "can match attributes" do
+      is_expected.to be_a_twirp_request(HelloRequest, **attrs)
+    end
+
+    it "supports regex matches" do
+      is_expected.to be_a_twirp_request(name: /^B/)
+    end
+
+    it "supports range matches" do
+      is_expected.to be_a_twirp_request(count: 1..5)
+    end
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_request(GoodbyeRequest, name: "Bob")
+      }.to fail_with /request of type/
+
+      expect {
+        is_expected.to be_a_twirp_request(name: "nope")
+      }.to fail_with /to have name: "nope"/
+
+      expect {
+        is_expected.to be_a_twirp_request(name: /no/)
+      }.to fail_with /to have name: \/no\//
+
+      expect {
+        is_expected.to be_a_twirp_request(count: 1)
+      }.to fail_with /to have count: 1/
+    end
+
+    it "catches the erroneous attribute matches" do
+      expect {
+        is_expected.to be_a_twirp_request(namezzz: "Bob")
+      }.to raise_error(ArgumentError, /namezzz/)
+    end
+
+    it "catches type mismatches" do
+      expect {
+        is_expected.to be_a_twirp_request(name: 123)
+      }.to raise_error(TypeError, /string field.*given Integer/)
+    end
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,56 @@
+describe "be_a_twirp_response" do
+  subject { HelloResponse.new(**attrs) }
+
+  let(:attrs) { {} }
+
+  it { is_expected.to be_a_twirp_response }
+
+  it "catches non-twirp response" do
+    expect {
+      expect(Object).to be_a_twirp_response
+    }.to fail_with /Expected a Twirp response, found Object/
+  end
+
+  it "matches a specific response type" do
+    is_expected.to be_a_twirp_request(HelloResponse)
+  end
+
+  it "catches type mismatches" do
+    expect {
+      is_expected.to be_a_twirp_request(GoodbyeResponse)
+    }.to fail_with /request of type GoodbyeResponse/
+  end
+
+  context "with attributes" do
+    let(:attrs) { { message: msg } }
+    let(:msg) { [ "Hello World" ] }
+
+    it { is_expected.to be_a_twirp_response(**attrs) }
+
+    it "supports regex matches" do
+      is_expected.to be_a_twirp_response(message: include(/Hello/))
+    end
+
+    it "catches mismatches" do
+      expect {
+        is_expected.to be_a_twirp_response(message: [ "" ])
+      }.to fail_with /to have message/
+
+      expect {
+        is_expected.to be_a_twirp_response(message: [ "Hello" ])
+      }.to fail_with /to have message/
+    end
+
+    it "catches the erroneous attributes" do
+      expect {
+        is_expected.to be_a_twirp_response(msg: [])
+      }.to raise_error(ArgumentError, /msg/)
+    end
+
+    it "catches type mismatches" do
+      expect {
+        is_expected.to be_a_twirp_response(message: "Hello World")
+      }.to raise_error(ArgumentError, /Expected array/)
+    end
+  end
+end

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: rspec-twirp
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Daniel Pepper
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-25 00:00:00.000000000 Z
+date: 2022-09-25 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: twirp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-expectations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -73,7 +101,16 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/rspec-twirp.rb
-- lib/rspec-twirp/version.rb
+- lib/rspec/twirp.rb
+- lib/rspec/twirp/client_response_matcher.rb
+- lib/rspec/twirp/error_matcher.rb
+- lib/rspec/twirp/request_matcher.rb
+- lib/rspec/twirp/response_matcher.rb
+- lib/rspec/twirp/version.rb
+- spec/client_response_spec.rb
+- spec/error_spec.rb
+- spec/request_spec.rb
+- spec/response_spec.rb
 homepage: https://github.com/dpep/rspec-twirp_rb
 licenses:
 - MIT
@@ -96,5 +133,9 @@ requirements: []
 rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
-summary: RSpecTwirp
-test_files: []
+summary: Gem::Specification::RSpec::Twirp
+test_files:
+- spec/error_spec.rb
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/client_response_spec.rb

data/lib/rspec-twirp/version.rb

@@ -1,3 +0,0 @@
-module RSpecTwirp
-  VERSION = "0.0.1"
-end