proto_pharm 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 404f9289692becf1d216f4c8a3dbdb574394035f4fe80849565931b61ecba9ba
+  data.tar.gz: 6bb014799feda5517ed91d065a92c3feb5955c253779d5bf312fd6abc81f7882
+SHA512:
+  metadata.gz: 84fc28f8e009deb5dee062d15b8eff4091219bb3af1b9ad1d83dd90399c171e1c19b435eb271258fdfb449e60d7210ef4a57a6d61ab5a9d23c22282ef9df476e
+  data.tar.gz: ed36363f230916dfcab696c78f517b78256e7d3e954e02665485d7a0faf8aa0eb518be92daba1f30c58d4f85b92b5d1556cade1ac1e986e4441433f288d74cb0

data/.github/workflows/rspec.yml

@@ -0,0 +1,35 @@
+name: RSpec
+
+on: push
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby:
+        - "2.6.x"
+        - "2.7.x"
+
+    steps:
+    - uses: actions/checkout@v1
+    - uses: actions/cache@v1
+      with:
+        path: vendor/bundle
+        key: ${{ runner.os }}-gems-${{ matrix.ruby }}-${{ hashFiles('**/Gemfile.lock') }}
+        restore-keys: |
+          ${{ runner.os }}-gems-${{ matrix.ruby }}
+    - name: Set up Ruby ${{ matrix.ruby }}
+      uses: actions/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Set up dependencies
+      env:
+          BUNDLE_GEM__FURY__IO: ${{ secrets.GEMFURY_DEPLOY_TOKEN }}
+      run: |
+        gem install bundler
+        bundle config path vendor/bundle
+        bundle install --jobs 4 --retry 3
+    - name: Run RSpec
+      run: |
+        bundle exec rspec

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,3 @@
+inherit_gem:
+  spicerack-styleguide:
+    - rubocop.yml

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.6.3
+  - 2.5.3
+  - 2.4.5
+before_install: gem install bundler -v 1.16.1

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+# 0.6.0
+*Release Date: 2020-12-07*
+
+- Rename gem to `proto_pharm`
+- Add support for `return_op` option([#1](https://github.com/Freshly/proto_pharm_old/pull/1), [#2](https://github.com/Freshly/proto_pharm_old/pull/2))
+- Fix load order bug ([#3](https://github.com/Freshly/proto_pharm_old/pull/3))
+- Add `stub_grpc_action` convenience method ([#9](https://github.com/Freshly/proto_pharm_old/pull/9), [#12](https://github.com/Freshly/proto_pharm_old/pull/12))
+- Add `to_fail_with` stub method ([#14](https://github.com/Freshly/proto_pharm_old/pull/14), [#18](https://github.com/Freshly/proto_pharm_old/pull/18))
+- Add `have_received_rpc` matcher ([#19](https://github.com/Freshly/proto_pharm_old/pull/19))
+- Add RSpec DSL ([#10](https://github.com/Freshly/proto_pharm_old/pull/10), [#26](https://github.com/Freshly/proto_pharm_old/pull/26))

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in proto_pharm.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,113 @@
+PATH
+  remote: .
+  specs:
+    proto_pharm (0.6.0)
+      activesupport (>= 5.2.0)
+      grpc (>= 1.12.0, < 2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.0.3.4)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    ast (2.4.1)
+    byebug (11.1.1)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.4.4)
+    faker (2.14.0)
+      i18n (>= 1.6, < 2)
+    google-protobuf (3.14.0)
+    googleapis-common-protos-types (1.0.5)
+      google-protobuf (~> 3.11)
+    grpc (1.34.0)
+      google-protobuf (~> 3.13)
+      googleapis-common-protos-types (~> 1.0)
+    grpc-tools (1.32.0)
+    i18n (1.8.5)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.2)
+    minitest (5.14.2)
+    parallel (1.20.1)
+    parser (2.7.2.0)
+      ast (~> 2.4.1)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.7.0)
+      byebug (~> 11.0)
+      pry (~> 0.10)
+    rack (2.2.3)
+    rainbow (3.0.0)
+    rake (13.0.1)
+    regexp_parser (1.8.2)
+    rexml (3.2.4)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.3)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.4)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.4)
+    rspice (0.25.2)
+      faker (>= 1.8, < 3.0)
+      rspec (~> 3.0)
+    rubocop (0.92.0)
+      parallel (~> 1.10)
+      parser (>= 2.7.1.5)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.5.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (1.1.1)
+      parser (>= 2.7.1.5)
+    rubocop-performance (1.8.1)
+      rubocop (>= 0.87.0)
+      rubocop-ast (>= 0.4.0)
+    rubocop-rails (2.8.1)
+      activesupport (>= 4.2.0)
+      rack (>= 1.1)
+      rubocop (>= 0.87.0)
+    rubocop-rspec (1.43.2)
+      rubocop (~> 0.87)
+    ruby-progressbar (1.10.1)
+    spicerack-styleguide (0.25.2)
+      rubocop (~> 0.92.0)
+      rubocop-performance (~> 1.8.0)
+      rubocop-rails (~> 2.8.0)
+      rubocop-rspec (~> 1.43.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.8)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.7.0)
+    zeitwerk (2.4.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  faker
+  grpc-tools
+  proto_pharm!
+  pry-byebug
+  rake (>= 12.3.3)
+  rspec (~> 3.0)
+  rspice
+  rubocop
+  spicerack-styleguide
+
+BUNDLED WITH
+   2.1.4

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Yuta Iwama
+
+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,238 @@
+# ProtoPharm
+
+Stub your gRPCs with lab-grown proto objects. Life is better on the pharm.
+
+Built on a great foundation by @ganmacs at [ganmacs/grpc_mock](https://github.com/ganmacs/grpc_mock).
+
+## Installation
+
+Add this line to your application's Gemfile in the development/test group:
+
+```ruby
+gem 'proto_pharm'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install proto_pharm
+
+## Let's go Pharming!
+
+Before we dive into the code - all examples below will refer to a gRPC service called `hello.hello` with (among others) an rpc endpoint `Hello` which receives the proto `hello.HelloRequest` and responds with the proto `hello.HelloResponse`.
+
+The local variable `client` is defined as follows:
+```ruby
+client = Hello::Hello::Stub.new('localhost:8000', :this_channel_is_insecure)
+``` 
+
+See full definition of protocol buffers and gRPC generated code in [spec/examples/hello](https://github.com/Freshly/proto_pharm/tree/master/spec/examples/hello).
+
+## RSpec Usage
+
+To take full advantage of the helpers listed here, make sure to add the following to your `spec_helper.rb` or `rails_helper.rb`:
+```ruby
+require 'proto_pharm/rspec'
+```
+
+### Stubbing service responses
+
+For the simplest use case, stub a response value for a given rpc endpoint like so:
+```ruby
+allow_grpc_service(Hello::Hello)
+  .to receive_rpc(:hello)
+  .and_return(msg: 'Hello!')
+
+client.hello(Hello::HelloRequest.new(msg: 'Hello?')) # => <Hello::HelloResponse: msg: "Hello!">
+```
+
+To stub a response for a specific request received:
+```ruby
+allow_grpc_service(Hello::Hello)
+  .to receive_rpc(:hello)
+  .with(msg: 'Hola?')
+  .and_return(msg: 'Bienvenidos!')
+
+client.hello(Hello::HelloRequest.new(msg: 'Hello?')) # => Sent to network
+client.hello(Hello::HelloRequest.new(msg: 'Hola?')) # => <Hello::HelloResponse: msg: "Bienvenidos!">
+```
+
+Stub a failure response:
+```ruby
+allow_grpc_service(Hello::Hello)
+  .to receive_rpc(:hello)
+  .and_fail_with(:not_found, "No one's here...")
+
+client.hello(Hello::HelloRequest.new(msg: 'Hello?')) # => <GRPC::NotFound: 5:No one's here...>
+```
+
+Stub failure metadata:
+```ruby
+allow_grpc_service(Hello::Hello)
+  .to receive_rpc(:hello)
+  .and_fail_with(:not_found, metadata: { people_here: :none })
+
+begin
+  client.hello(Hello::HelloRequest.new(msg: 'Hello?'))
+rescue => e
+  e  # => <GRPC::NotFound: 5:>
+  e.metadata # => {:people_here=>"none"}
+end
+```
+Note here that the `"none"` value is a string - all metadata values will be cast as strings on response to emulate actual gRPC behavior.
+
+Or, if you just want the call to fail and don't care about the failure type, it defaults to `:invalid_argument`:
+```ruby
+allow_grpc_service(Hello::Hello).to receive_rpc(:hello).and_fail
+client.hello(Hello::HelloRequest.new(msg: 'Hello?')) # => <GRPC::InvalidArgument: 3:>
+
+# Or with some metadata...
+
+allow_grpc_service(Hello::Hello).to receive_rpc(:hello).and_fail_with(metadata: { some: :meta_here })
+client.hello(Hello::HelloRequest.new(msg: 'Hello?')) # => You get the picture
+```
+
+#### Asserting RPC reception
+
+ProtoPharm also adds a matcher to assert rpc reception. For example:
+```ruby
+allow_grpc_service(Hello::Hello)
+  .to receive_rpc(:hello)
+  .and_return(msg: 'Hello!')
+
+client.hello(Hello::HelloRequest.new(msg: 'Hello?'))
+expect(Hello::Hello).to have_received_rpc(:hello)
+```
+
+You can also assert the arguments received:
+```ruby
+expect(Hello::Hello).to have_received_rpc(:hello).with(msg: 'Hello?')
+```
+
+### Argument Flexibility
+You may have noticed that the above examples stub proto objects without specifying the proto type (for example, `.and_return(msg: 'Hello!')`). No `Hello::HelloRequest.new`s in sight! Both `with` and `and_return` will happily accept protos, hashes or keyword args. If you pass an invalid key to a stub method, you'll get an error:
+```ruby
+allow_grpc_service(Hello::Hello).to receive_rpc(:hello).and_return(message: "Is this thing on?")
+# => ArgumentError: Unknown field name 'message' in initialization map entry.
+```
+
+Happy stubbing!
+
+## Usage for Minitest etc.
+
+### Stubbed request based on path and with the default response
+
+```ruby
+ProtoPharm.stub_request("/hello.hello/Hello").to_return(Hello::HelloResponse.new(msg: 'test'))
+
+client.hello(Hello::HelloRequest.new(msg: 'hi')) # => Hello::HelloResponse.new(msg: 'test')
+```
+
+### Stubbing requests based on path and request
+
+```ruby
+ProtoPharm.stub_request("/hello.hello/Hello").with(Hello::HelloRequest.new(msg: 'hi')).to_return(Hello::HelloResponse.new(msg: 'test'))
+
+client.hello(Hello::HelloRequest.new(msg: 'hello')) # => send a request to server
+client.hello(Hello::HelloRequest.new(msg: 'hi'))    # => Hello::HelloResponse.new(msg: 'test') (without any requests to server)
+```
+
+### Stubbing per-action requests based on parametrized request
+
+```ruby
+ProtoPharm.stub_grpc_action(Hello::Hello::Service, :Hello).with(msg: 'hi').to_return(msg: 'test')
+
+client.hello(Hello::HelloRequest.new(msg: 'hello')) # => send a request to server
+client.hello(Hello::HelloRequest.new(msg: 'hi'))    # => Hello::HelloResponse.new(msg: 'test') (without any requests to server)
+
+```
+
+### You can user either proto objects or hash for stubbing requests
+
+```ruby
+ProtoPharm.stub_grpc_action(Hello::Hello::Service, :Hello).with(Hello::HelloRequest.new(msg: 'hi')).to_return(msg: 'test')
+# or
+ProtoPharm.stub_grpc_action(Hello::Hello::Service, :Hello).with(msg: 'hi').to_return(Hello::HelloResponse.new(msg: 'test'))
+
+client.hello(Hello::HelloRequest.new(msg: 'hello')) # => send a request to server
+client.hello(Hello::HelloRequest.new(msg: 'hi'))    # => Hello::HelloResponse.new(msg: 'test') (without any requests to server)
+```
+
+### Real requests to network can be allowed or disabled
+
+```ruby
+client = Hello::Hello::Stub.new('localhost:8000', :this_channel_is_insecure)
+
+ProtoPharm.disable_net_connect!
+client.hello(Hello::HelloRequest.new(msg: 'hello')) # => Raise NetConnectNotAllowedError error
+
+ProtoPharm.allow_net_connect!
+Hello::Hello::Stub.new('localhost:8000', :this_channel_is_insecure) # => send a request to server
+```
+
+### Stubbing Failures
+
+Specific gRPC failure codes can be stubbed with metadata
+```ruby
+ProtoPharm.
+  stub_grpc_action(Hello::Hello::Service, :Hello).
+    with(Hello::HelloRequest.new(msg: 'hi')).
+    to_fail_with(:invalid_argument, "This message is optional", metadata: { put: :your, metadata: :here })
+    
+begin 
+  client.hello(Hello::HelloRequest.new(msg: 'hi'))
+rescue => e
+  e # => #<GRPC::InvalidArgument: 3:This message is optional>
+  e.metadata # => { :put => :your, :metadata => here }
+```
+
+By default, The failure code is `invalid_argument` and the message is optional - so if the code under test doesn't rely on those for any downstream behavior, you can simplify the stubbing by passing only metadata:
+```ruby
+stub_grpc_action(Hello::Hello::Service, :Hello).
+  to_fail_with(metadata: { important_things: [:in, :here] })
+client.hello(Hello::HelloRequest.new(msg: 'hi')) 
+# => #<GRPC::InvalidArgument: 3:>
+exception.metadata 
+# => { :important_things => [:in, :here] }
+
+```
+...or by passing nothing at all:
+```ruby
+stub_grpc_action(Hello::Hello::Service, :Hello).to_fail
+client.hello(Hello::HelloRequest.new(msg: 'hi')) 
+# => #<GRPC::InvalidArgument: 3:>
+```
+
+### Raising errors
+
+**Exception declared by class**
+
+```ruby
+ProtoPharm.stub_request("/hello.hello/Hello").to_raise(StandardError)
+
+client = Hello::Hello::Stub.new('localhost:8000', :this_channel_is_insecure)
+client.hello(Hello::HelloRequest.new(msg: 'hi')) # => Raise StandardError
+```
+
+**or by exception instance**
+
+```ruby
+ProtoPharm.stub_request("/hello.hello/Hello").to_raise(StandardError.new("Some error"))
+```
+
+**or by string**
+
+```ruby
+ProtoPharm.stub_request("/hello.hello/Hello").to_raise("Some error")
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Freshly/proto_pharm. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).