shopify-tcr 0.0.5.pre.shopify

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5765907faf7f2ab832ec3c3d3b5477cd88dedda1
+  data.tar.gz: 3ab7b0a348ed8ec457f26cc910eba7c33aa602b7
+SHA512:
+  metadata.gz: 7b6358e5fca32fba779383cb6f0b12f39a00d03f443bc9940eb12e37442058c1c4c055e82914fe42684fe5268f77518605dfb263b368dd6136116c9b4a8ec4b8
+  data.tar.gz: f9c552dc0527e9f190393a85b7fa66997915e111db60293390d77b4c1e8424ca0a19d480c4535f198ad7ae9dd83048b774fd061c46f947bb92583bbb6aac983a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3@tcr --create

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tcr.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Rob Forman
+
+MIT License
+
+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,72 @@
+# TCR (TCP + VCR)
+
+TCR is a *very* lightweight version of [VCR](https://github.com/vcr/vcr) for TCP sockets.
+
+Currently used for recording 'net/smtp' interactions so only a few of the TCPSocket methods are recorded out.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'tcr'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tcr
+
+## Usage
+
+```ruby
+require 'test/unit'
+require 'tcr'
+
+TCR.configure do |c|
+  c.cassette_library_dir = 'fixtures/tcr_cassettes'
+  c.hook_tcp_ports = [25]
+end
+
+class TCRTest < Test::Unit::TestCase
+  def test_example_dot_com
+    TCR.use_cassette('google_smtp') do
+      tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+      io = Net::InternetMessageIO.new(tcp_socket)
+      assert_match /220 mx.google.com ESMTP/, io.readline
+    end
+  end
+end
+```
+
+Run this test once, and TCR will record the tcp interactions to fixtures/tcr_cassettes/google_smtp.json.
+
+```json
+[
+  [
+    [
+      "read",
+      "220 mx.google.com ESMTP x3si2474860qas.18 - gsmtp\r\n"
+    ]
+  ]
+]
+```
+
+Run it again, and TCR will replay the interactions from json when the tcp request is made. This test is now fast (no real TCP requests are made anymore), deterministic and accurate.
+
+You can disable TCR hooking TCPSocket ports for a given block via `turned_off`:
+
+```ruby
+TCR.turned_off do
+  tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/lib/tcr.rb

@@ -0,0 +1,67 @@
+require "tcr/cassette"
+require "tcr/configuration"
+require "tcr/errors"
+require "tcr/recordable"
+require "tcr/socket_extension"
+require "tcr/ssl_socket_extension"
+require "tcr/version"
+require "socket"
+require "json"
+
+module TCR
+  ALL_PORTS = '*'
+
+  extend self
+
+  def configure
+    yield configuration
+  end
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def cassette
+    @cassette
+  end
+
+  def cassette=(v)
+    @cassette = v
+  end
+
+  def disabled
+    @disabled || false
+  end
+
+  def disabled=(v)
+    @disabled = v
+  end
+
+  def record_port?(port)
+    !disabled && configuration.hook_tcp_ports == ALL_PORTS || configuration.hook_tcp_ports.include?(port)
+  end
+
+  def use_cassette(name, options = {}, &block)
+    raise ArgumentError, "`TCR.use_cassette` requires a block." unless block
+    begin
+      TCR.cassette = Cassette.build(name)
+      yield TCR.cassette
+    ensure
+      TCR.cassette.finish
+      TCR.cassette = nil
+    end
+  end
+
+  def turned_off(&block)
+    raise ArgumentError, "`TCR.turned_off` requires a block." unless block
+    begin
+      disabled = true
+      yield
+    ensure
+      disabled = false
+    end
+  end
+end
+
+TCPSocket.prepend(TCR::SocketExtension)
+OpenSSL::SSL::SSLSocket.send(:include, TCR::SSLSocketExtension)

data/lib/tcr/cassette.rb

@@ -0,0 +1,176 @@
+module TCR
+  class Cassette
+    attr_reader :name
+
+    def self.build(name)
+      if cassette_exists?(name)
+        RecordedCassette.new(name)
+      else
+        RecordingCassette.new(name)
+      end
+    end
+
+    def self.filename(name)
+      "#{TCR.configuration.cassette_library_dir}/#{name}.json"
+    end
+
+    def self.cassette_exists?(name)
+      File.exists?(filename(name))
+    end
+
+    def initialize(name)
+      @name = name
+    end
+
+    protected
+
+    def filename
+      self.class.filename(name)
+    end
+
+    class RecordingCassette < Cassette
+      attr_reader :originally_recorded_at
+
+      def initialize(*args)
+        super
+        @originally_recorded_at = Time.now
+      end
+
+      def sessions
+        @sessions ||= []
+      end
+
+      def next_session
+        Session.new.tap do |session|
+          sessions << session
+        end
+      end
+
+      def finish
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.open(filename, "w") { |f| f.write(serialized_form) }
+      end
+
+      private
+
+      def serialized_form
+        raw = {
+          "originally_recorded_at" => originally_recorded_at,
+          'sessions' => sessions.map(&:as_json)
+        }
+        JSON.pretty_generate(raw)
+      end
+
+      def empty?
+        true
+      end
+
+      class Session
+        def initialize
+          @recording = []
+        end
+
+        def connect(&block)
+          next_command('connect', ret: nil, &block)
+        end
+
+        def close(&block)
+          next_command('close', &block)
+        end
+
+        def read(*args, &block)
+          next_command('read', data: args, &block)
+        end
+
+        def write(str, &block)
+          next_command('write', data: str, &block)
+        end
+
+        def as_json
+          {"recording" => @recording}
+        end
+
+        private
+
+        def next_command(command, options={}, &block)
+          yield.tap do |return_value|
+            return_value = options[:ret] if options.has_key?(:ret)
+            @recording << [command, return_value] + Array(options[:data])
+          end
+        end
+      end
+    end
+
+    class RecordedCassette < Cassette
+      def sessions
+        @sessions ||= serialized_form['sessions'].map{|raw| Session.new(raw)}
+      end
+
+      def originally_recorded_at
+        serialized_form['originally_recorded_at']
+      end
+
+      def next_session
+        session = sessions.shift
+        raise NoMoreSessionsError unless session
+        session
+      end
+
+      def finish
+        # no-op
+      end
+
+      def empty?
+        sessions.all?(&:empty?)
+      end
+
+      private
+
+      def serialized_form
+        @serialized_form ||= begin
+          raw = File.open(filename) { |f| f.read }
+          JSON.parse(raw)
+        end
+      end
+
+      class Session
+        def initialize(raw)
+          @recording = raw["recording"]
+        end
+
+        def connect
+          next_command('connect')
+        end
+
+        def close
+          next_command('close')
+        end
+
+        def read(*args)
+          next_command('read') do |str, *data|
+            raise TCR::DataMismatchError.new("Expected to read to be called with args '#{args.inspect}' but was called with '#{data.inspect}'") unless args == data
+          end
+        end
+
+        def write(str)
+          next_command('write') do |len, data|
+            raise TCR::DataMismatchError.new("Expected to write '#{str}' but next data in recording was '#{data}'") unless str == data
+          end
+        end
+
+        def empty?
+          @recording.empty?
+        end
+
+        private
+
+        def next_command(expected)
+          command, return_value, data = @recording.shift
+          raise TCR::CommandMismatchError.new("Expected to '#{expected}' but next in recording was '#{command}'") unless expected == command
+          yield return_value, *data if block_given?
+          return_value
+        end
+      end
+    end
+  end
+end

data/lib/tcr/configuration.rb

@@ -0,0 +1,14 @@
+module TCR
+  class Configuration
+    attr_accessor :cassette_library_dir, :hook_tcp_ports
+
+    def initialize
+      reset_defaults!
+    end
+
+    def reset_defaults!
+      @cassette_library_dir = "fixtures/tcr_cassettes"
+      @hook_tcp_ports = []
+    end
+  end
+end

data/lib/tcr/errors.rb

@@ -0,0 +1,6 @@
+module TCR
+  class TCRError < StandardError; end
+  class NoMoreSessionsError < TCRError; end
+  class CommandMismatchError < TCRError; end
+  class DataMismatchError < TCRError; end
+end

data/lib/tcr/recordable.rb

@@ -0,0 +1,45 @@
+module TCR
+  module Recordable
+    attr_accessor :cassette
+
+    def recording
+      @recording ||= cassette.next_session
+    end
+
+    def connect
+      recording.connect do
+        super
+      end
+    end
+
+    def read_nonblock(bytes)
+      recording.read do
+        super
+      end
+    end
+
+    def gets(*args)
+      recording.read do
+        super
+      end
+    end
+
+    def write(str)
+      recording.write(str) do
+        super
+      end
+    end
+
+    def read(*args)
+      recording.read do
+        super
+      end
+    end
+
+    def close
+      recording.close do
+        super
+      end
+    end
+  end
+end

data/lib/tcr/socket_extension.rb

@@ -0,0 +1,11 @@
+module TCR
+  module SocketExtension
+    def initialize(address, port, *args)
+      super
+      if TCR.record_port?(port) && TCR.cassette
+        extend(Recordable)
+        self.cassette = TCR.cassette
+      end
+    end
+  end
+end

data/lib/tcr/ssl_socket_extension.rb

@@ -0,0 +1,16 @@
+module TCR
+  module SSLSocketExtension
+    def self.included(klass)
+      klass.send(:alias_method, :initialize_without_tcr, :initialize)
+      klass.send(:alias_method, :initialize, :initialize_with_tcr)
+    end
+
+    def initialize_with_tcr(s, context)
+      initialize_without_tcr(s, context)
+      if TCR.record_port?(s.remote_address.ip_port) && TCR.cassette
+        extend(TCR::Recordable)
+        self.cassette = TCR.cassette
+      end
+    end
+  end
+end

data/lib/tcr/version.rb

@@ -0,0 +1,3 @@
+module TCR
+  VERSION = "0.0.5-shopify"
+end

data/spec/fixtures/google_smtp.json

@@ -0,0 +1,12 @@
+{
+  "sessions": [
+    {
+      "recording": [
+        [
+          "read",
+          "220 mx.google.com ESMTP x3si2474860qas.18 - gsmtp\r\n"
+        ]
+      ]
+    }
+  ]
+}

data/spec/fixtures/multitest-smtp.json

@@ -0,0 +1,56 @@
+{
+  "sessions": [
+    {
+      "recording": [
+        [
+          "read",
+          "220 mx.google.com ESMTP d8si2472149qai.124 - gsmtp\r\n"
+        ],
+        [
+          "write",
+          16,
+          "EHLO localhost\r\n"
+        ],
+        [
+          "read",
+          "250-mx.google.com at your service, [54.227.243.167]\r\n250-SIZE 35882577\r\n250-8BITMIME\r\n250-STARTTLS\r\n250 ENHANCEDSTATUSCODES\r\n"
+        ],
+        [
+          "write",
+          6,
+          "QUIT\r\n"
+        ],
+        [
+          "read",
+          "221 2.0.0 closing connection d8si2472149qai.124 - gsmtp\r\n"
+        ]
+      ]
+    },
+    {
+      "recording": [
+        [
+          "read",
+          "220 mta1579.mail.gq1.yahoo.com ESMTP YSmtpProxy service ready\r\n"
+        ],
+        [
+          "write",
+          16,
+          "EHLO localhost\r\n"
+        ],
+        [
+          "read",
+          "250-mta1579.mail.gq1.yahoo.com\r\n250-8BITMIME\r\n250-SIZE 41943040\r\n250 PIPELINING\r\n"
+        ],
+        [
+          "write",
+          6,
+          "QUIT\r\n"
+        ],
+        [
+          "read",
+          "221 mta1579.mail.gq1.yahoo.com\r\n"
+        ]
+      ]
+    }
+  ]
+}

data/spec/fixtures/multitest.json

@@ -0,0 +1,20 @@
+{
+  "sessions": [
+    {
+      "recording": [
+        [
+          "read",
+          "220 mx.google.com ESMTP h5si2286277qec.54 - gsmtp\r\n"
+        ]
+      ]
+    },
+    {
+      "recording": [
+        [
+          "read",
+          "220 mta1009.mail.gq1.yahoo.com ESMTP YSmtpProxy service ready\r\n"
+        ]
+      ]
+    }
+  ]
+}

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # 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
+  config.order = 'random'
+end

data/spec/tcr_spec.rb

@@ -0,0 +1,151 @@
+require "spec_helper"
+require "tcr"
+require "net/protocol"
+require "net/smtp"
+
+describe TCR do
+  before(:each) do
+    TCR.configuration.reset_defaults!
+  end
+
+  describe ".configuration" do
+     it "has a default cassette location configured" do
+       TCR.configuration.cassette_library_dir.should == "fixtures/tcr_cassettes"
+     end
+
+     it "has an empty list of hook ports by default" do
+       TCR.configuration.hook_tcp_ports.should == []
+     end
+   end
+
+   describe ".configure" do
+     it "configures cassette location" do
+       expect {
+         TCR.configure { |c| c.cassette_library_dir = "some/dir" }
+       }.to change{ TCR.configuration.cassette_library_dir }.from("fixtures/tcr_cassettes").to("some/dir")
+     end
+
+     it "configures tcp ports to hook" do
+       expect {
+         TCR.configure { |c| c.hook_tcp_ports = [25] }
+       }.to change{ TCR.configuration.hook_tcp_ports }.from([]).to([25])
+     end
+   end
+
+  describe ".turned_off" do
+    it "requires a block to call" do
+      expect {
+        TCR.turned_off
+      }.to raise_error(ArgumentError)
+    end
+
+    it "makes real TCPSocket.open calls even when hooks are setup" do
+      TCR.configure { |c| c.hook_tcp_ports = [25] }
+      TCR.turned_off do
+        tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+        expect(tcp_socket).not_to respond_to(:cassette)
+      end
+    end
+  end
+
+  describe ".use_cassette" do
+    before(:each) {
+      TCR.configure { |c|
+        c.hook_tcp_ports = [25]
+        c.cassette_library_dir = "."
+      }
+      File.unlink("test.json") if File.exists?("test.json")
+    }
+    after(:each) {
+      File.unlink("test.json") if File.exists?("test.json")
+    }
+
+    it "requires a block to call" do
+      expect {
+        TCR.use_cassette("test")
+      }.to raise_error(ArgumentError)
+    end
+
+    it "resets the cassette after use" do
+      expect(TCR.cassette).to be_nil
+      TCR.use_cassette("test") { }
+      expect(TCR.cassette).to be_nil
+    end
+
+    it "creates a cassette file on use" do
+      expect {
+        TCR.use_cassette("test") do
+          tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+          tcp_socket.close
+        end
+      }.to change{ File.exists?("./test.json") }.from(false).to(true)
+    end
+
+    it "records the tcp session data into the file" do
+      TCR.use_cassette("test") do
+        tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+        io = Net::InternetMessageIO.new(tcp_socket)
+        line = io.readline
+        tcp_socket.close
+      end
+      cassette_contents = File.open("test.json") { |f| f.read }
+      cassette_contents.include?("220 mx.google.com ESMTP").should == true
+    end
+
+    it "plays back tcp sessions without opening a real connection" do
+      TCR.use_cassette("spec/fixtures/google_smtp") do
+        tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+        expect(tcp_socket).to respond_to(:cassette)
+        io = Net::InternetMessageIO.new(tcp_socket)
+        line = io.readline.should include("220 mx.google.com ESMTP")
+      end
+    end
+
+    it "raises an error if the recording gets out of order (i.e., we went to write but it expected a read)" do
+      expect {
+        TCR.use_cassette("spec/fixtures/google_smtp") do
+          tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+          io = Net::InternetMessageIO.new(tcp_socket)
+          io.write("hi")
+        end
+      }.to raise_error(TCR::CommandMismatchError)
+    end
+
+
+    context "multiple connections" do
+      it "records multiple sessions per cassette" do
+        TCR.use_cassette("test") do
+          smtp = Net::SMTP.start("aspmx.l.google.com", 25)
+          smtp.finish
+          smtp = Net::SMTP.start("mta6.am0.yahoodns.net", 25)
+          smtp.finish
+        end
+        cassette_contents = File.open("test.json") { |f| f.read }
+        cassette_contents.include?("google.com ESMTP").should == true
+        cassette_contents.include?("yahoo.com ESMTP").should == true
+      end
+
+      it "plays back multiple sessions per cassette in order" do
+        TCR.use_cassette("spec/fixtures/multitest") do
+          tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+          io = Net::InternetMessageIO.new(tcp_socket)
+          line = io.readline.should include("google.com ESMTP")
+
+          tcp_socket = TCPSocket.open("mta6.am0.yahoodns.net", 25)
+          io = Net::InternetMessageIO.new(tcp_socket)
+          line = io.readline.should include("yahoo.com ESMTP")
+        end
+      end
+
+      it "raises an error if you try to playback more sessions than you previously recorded" do
+        expect {
+          TCR.use_cassette("spec/fixtures/multitest-smtp") do
+            smtp = Net::SMTP.start("aspmx.l.google.com", 25)
+            smtp = Net::SMTP.start("mta6.am0.yahoodns.net", 25)
+            smtp = Net::SMTP.start("mta6.am0.yahoodns.net", 25)
+          end
+        }.to raise_error(TCR::NoMoreSessionsError)
+      end
+    end
+  end
+end

data/tcr.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tcr/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "shopify-tcr"
+  gem.version       = TCR::VERSION
+  gem.authors       = ["Luke Hutscal"]
+  gem.email         = 'luke.hutscal@shopify.com'
+  gem.description   = %q{TCR is a lightweight VCR for TCP sockets.}
+  gem.summary       = %q{TCR is a lightweight VCR for TCP sockets.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "geminabox"
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: shopify-tcr
+version: !ruby/object:Gem::Version
+  version: 0.0.5.pre.shopify
+platform: ruby
+authors:
+- Luke Hutscal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: geminabox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: TCR is a lightweight VCR for TCP sockets.
+email: luke.hutscal@shopify.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rvmrc"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tcr.rb
+- lib/tcr/cassette.rb
+- lib/tcr/configuration.rb
+- lib/tcr/errors.rb
+- lib/tcr/recordable.rb
+- lib/tcr/socket_extension.rb
+- lib/tcr/ssl_socket_extension.rb
+- lib/tcr/version.rb
+- spec/fixtures/google_smtp.json
+- spec/fixtures/multitest-smtp.json
+- spec/fixtures/multitest.json
+- spec/spec_helper.rb
+- spec/tcr_spec.rb
+- tcr.gemspec
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: TCR is a lightweight VCR for TCP sockets.
+test_files:
+- spec/fixtures/google_smtp.json
+- spec/fixtures/multitest-smtp.json
+- spec/fixtures/multitest.json
+- spec/spec_helper.rb
+- spec/tcr_spec.rb