tcr 0.0.1

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,51 @@
+# 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. 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.
+
+## 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,53 @@
+require "tcr/configuration"
+require "tcr/errors"
+require "tcr/recordable_tcp_socket"
+require "tcr/version"
+require "socket"
+require "json"
+
+
+module TCR
+  extend self
+
+  def configure
+    yield configuration
+  end
+
+  def configuration
+    @configuration ||= Configuration.new
+  end
+
+  def current_cassette
+    raise TCR::NoCassetteError unless @current_cassette
+    @current_cassette
+  end
+
+  def use_cassette(name, options = {}, &block)
+    raise ArgumentError, "`TCR.use_cassette` requires a block." unless block
+    set_cassette(name)
+    yield
+    @current_cassette = nil
+  end
+
+  protected
+
+  def set_cassette(name)
+    @current_cassette = "#{TCR.configuration.cassette_library_dir}/#{name}.json"
+  end
+end
+
+
+# The monkey patch shim
+class TCPSocket
+  class << self
+    alias_method :real_open,  :open
+
+    def open(address, port)
+      if TCR.configuration.hook_tcp_ports.include?(port)
+        TCR::RecordableTCPSocket.new(address, port, TCR.current_cassette)
+      else
+        real_open(address, port)
+      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,5 @@
+module TCR
+  class TCRError < StandardError; end
+  class NoCassetteError < TCRError; end
+  class DirectionMismatchError < TCRError; end
+end

data/lib/tcr/recordable_tcp_socket.rb

@@ -0,0 +1,65 @@
+module TCR
+  class RecordableTCPSocket
+    attr_reader :live, :recording_file
+    attr_accessor :recordings
+
+    def initialize(address, port, recording_file)
+      @recording_file = recording_file
+
+      if File.exists?(recording_file)
+        @live = false
+        @recordings = JSON.parse(File.open(recording_file, "r") { |f| f.read })
+      else
+        @live = true
+        @recordings = []
+        @socket = TCPSocket.real_open(address, port)
+      end
+    end
+
+    def read_nonblock(bytes)
+      if live
+        data = @socket.read_nonblock(bytes)
+        recordings << ["read", data]
+      else
+        direction, data = recordings.shift
+        raise DirectionMismatchError("Expected to 'read' but next in recording was 'write'") unless direction == "read"
+      end
+
+      data
+    end
+
+    def write(str)
+      if live
+        len = @socket.write(str)
+        recordings << ["write", str]
+      else
+        direction, data = recordings.shift
+        raise DirectionMismatchError("Expected to 'write' but next in recording was 'read'") unless direction == "write"
+        len = data.length
+      end
+
+      len
+    end
+
+    def to_io
+      if live
+        @socket.to_io
+      end
+    end
+
+    def closed?
+      if live
+        @socket.closed?
+      else
+        false
+      end
+    end
+
+    def close
+      if live
+        @socket.close
+        File.open(recording_file, "w") { |f| f.write(JSON.pretty_generate(recordings)) }
+      end
+    end
+  end
+end

data/lib/tcr/version.rb

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

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,79 @@
+require "spec_helper"
+require "tcr"
+require "net/protocol"
+
+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 ".confige" 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
+
+   it "raises an error if you connect to a hooked port without using a cassette" do
+     TCR.configure { |c| c.hook_tcp_ports = [25] }
+     expect {
+       tcp_socket = TCPSocket.open("aspmx.l.google.com", 25)
+     }.to raise_error(TCR::NoCassetteError)
+   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 "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
+      file_contents = File.open("./test.json") { |f| f.read }
+      file_contents.include?("220 mx.google.com ESMTP").should == true
+    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          = "tcr"
+  gem.version       = TCR::VERSION
+  gem.authors       = ["Rob Forman"]
+  gem.email         = ["rob@robforman.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,93 @@
+--- !ruby/object:Gem::Specification
+name: tcr
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rob Forman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: geminabox
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: TCR is a lightweight VCR for TCP sockets.
+email:
+- rob@robforman.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/tcr.rb
+- lib/tcr/configuration.rb
+- lib/tcr/errors.rb
+- lib/tcr/recordable_tcp_socket.rb
+- lib/tcr/version.rb
+- spec/spec_helper.rb
+- spec/tcr_spec.rb
+- tcr.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: TCR is a lightweight VCR for TCP sockets.
+test_files:
+- spec/spec_helper.rb
+- spec/tcr_spec.rb