eval_in 0.1.6 → 0.2.0

data/spec/http_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+# This code is mostly tested through tests on the higher level things it depends on
+# But for a few small helpers, I wanted to just hit a lot of edge cases to really
+# give myself confidence they did what I was expecting.
+RSpec.describe EvalIn::HTTP do
+  describe '.jsonify_url' do
+    def assert_transforms(initial_url, expected_url)
+      actual_url = EvalIn::HTTP.jsonify_url initial_url
+      expect(actual_url).to eq expected_url
+    end
+
+    it 'appends .json to a url that is missing it' do
+      assert_transforms 'http://eval.in/1',          'http://eval.in/1.json'
+      assert_transforms 'http://eval.in/1.json',     'http://eval.in/1.json'
+
+      assert_transforms 'http://eval.in/1?a=b',      'http://eval.in/1.json?a=b'
+      assert_transforms 'http://eval.in/1.json?a=b', 'http://eval.in/1.json?a=b'
+    end
+
+    it 'changes .not-json to .json' do
+      assert_transforms 'http://eval.in/1.xml',      'http://eval.in/1.json'
+      assert_transforms 'http://eval.in/1.html',     'http://eval.in/1.json'
+      assert_transforms 'http://eval.in/1.html?a=b', 'http://eval.in/1.json?a=b'
+    end
+  end
+end

data/spec/mock_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+require 'eval_in/mock'
+
+
+# TODO: look at other reasons the thing could blow up, do we need to provide the mock a way to do these things?
+RSpec.describe EvalIn::Mock do
+  def is_jruby?
+    defined? RUBY_ENGINE and RUBY_ENGINE == 'jruby'
+  end
+
+  specify 'instances provide the same methods with the same signatures as the EvalIn class' do
+    mock = described_class.new
+    EvalIn.methods(false).each do |method_name|
+      expected_signature = EvalIn.method(method_name).parameters
+      actual_signature   = mock.method(method_name).parameters
+      expect(actual_signature).to eq expected_signature
+    end
+  end
+
+  describe '#call' do
+    context 'when initialized with a mock result' do
+      it 'returns the mock result' do
+        result = Object.new
+        mock   = described_class.new result: result
+        expect(mock.call "code", language: '').to equal result
+      end
+      it 'raises an ArgumentError if no language is provided' do
+        mock = described_class.new result: Object.new
+        expect { mock.call "code"               }.to     raise_error ArgumentError
+        expect { mock.call "code", language: '' }.to_not raise_error
+      end
+    end
+
+    context 'when initialized with an on_call proc' do
+      it 'passes the code and options to the proc and returns the result' do
+        mock = described_class.new on_call: -> code, options {
+          expect(code).to eq 'on_call code'
+          expect(options).to eq language: 'l'
+          123
+        }
+        expect(mock.call "on_call code", language: "l").to eq 123
+      end
+
+      it 'raises an ArgumentError if no language is provided' do
+        mock = described_class.new on_call: -> * {}
+        expect { mock.call "code"               }.to     raise_error ArgumentError
+        expect { mock.call "code", language: '' }.to_not raise_error
+      end
+    end
+
+    context 'when initialized without a a result or on_call proc' do
+      before do
+        if is_jruby?
+          pending "I can't figure out how to get JRuby to execute a fucking process"
+          raise "Why did RSpec remove the block form of pending?"
+        end
+      end
+
+      it 'executes the code with open3 against the list of language mappings' do
+        mock = described_class.new(languages: {
+          'correct-lang'   => {program: 'echo', args: ['RIGHT LANGUAGE']},
+          'incorrect-lang' => {program: 'echo', args: ['WRONG LANGUAGE']},
+        })
+        result = mock.call 'some code', language: 'correct-lang'
+        expect(result.output).to start_with 'RIGHT LANGUAGE'
+      end
+
+      def result_from(options={})
+        language     = options.fetch :language,     'dummy language'
+        code         = options.fetch :code,         'dummy code'
+        program_code = options.fetch :program_code, '# noop'
+
+        described_class.new(languages: {
+          language => {
+            program: RbConfig.ruby,
+            args:    ['-e', program_code]
+          }
+        }).call(code, language: language)
+      end
+
+      it 'records stderr and stdout' do
+        result = result_from program_code: '$stdout.print("STDOUT "); $stdout.flush; $stderr.print("STDERR")'
+        expect(result.output).to eq 'STDOUT STDERR'
+      end
+
+      it 'records the exit status' do
+        expect(result_from(program_code: 'exit 12').exitstatus).to eq 12
+        expect(result_from(program_code: 'exit 99').exitstatus).to eq 99
+      end
+
+      it 'sets the language and language_friendly to the provided language' do
+        result = result_from language: 'the-lang'
+        expect(result.language).to eq 'the-lang'
+        expect(result.language_friendly).to eq 'the-lang'
+      end
+
+      it 'sets the code to the provided code' do
+        expect(result_from(code: 'the-code').code).to eq 'the-code'
+      end
+
+      it 'sets the url to my mock result at https://eval.in/207744.json' do
+        expect(result_from().url).to eq 'https://eval.in/207744.json'
+      end
+
+      it 'sets the status to something looking like a real status' do
+        # in this case, just the status from https://eval.in/207744.json
+        expect(result_from().status).to match success_status_regex
+      end
+
+      it 'blows up if asked for a language it doesn\'t know how to evaluate' do
+        expect { described_class.new.call '', language: 'no-such-lang' }
+          .to raise_error KeyError, /no-such-lang/
+      end
+
+      it 'raises an ArgumentError if no language is provided' do
+        mock = described_class.new languages: {'l' => {program: 'echo', args: []}}
+        expect { mock.call "code"                }.to     raise_error ArgumentError
+        expect { mock.call "code", language: 'l' }.to_not raise_error
+      end
+    end
+  end
+
+  describe '#fetch_result' do
+    context 'when initialized with a mock result' do
+      it 'returns the mock result' do
+        result = Object.new
+        mock   = described_class.new(result: result)
+        expect(mock.fetch_result "code").to equal result
+      end
+    end
+
+    context 'when initialized with an on_fetch_result proc' do
+      it 'passes the url and options to the proc and returns the result' do
+        mock = described_class.new on_fetch_result: -> url, options {
+          expect(url).to eq 'some url'
+          expect(options).to eq a: 'b'
+          123
+        }
+        expect(mock.fetch_result 'some url', a: 'b').to eq 123
+      end
+    end
+
+    context 'when initialized without a result or on_fetch_result proc' do
+      include WebMock::API
+
+      it 'delegates to the real implementation' do
+        url         = "http://example.com/some-result.json"
+        result_hash = {'lang_friendly' => 'some lang friendly',
+                       'lang'          => 'some lang',
+                       'code'          => 'some code',
+                       'output'        => 'some output',
+                       'status'        => 'some status'}
+        stub_request(:get, url)
+          .with(headers: {'User-Agent' => 'http://rubygems.org/gems/eval_in (context)'})
+          .to_return(status: 200, body: JSON.dump(result_hash))
+        result = described_class.new.fetch_result("http://example.com/some-result.json", context: 'context')
+        assert_result result,
+                      exitstatus:        0,
+                      language:          result_hash['lang'],
+                      language_friendly: result_hash['lang_friendly'],
+                      code:              result_hash['code'],
+                      output:            result_hash['output'],
+                      status:            result_hash['status'],
+                      url:               url
+      end
+    end
+  end
+end

data/spec/result_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+RSpec.describe EvalIn::Result do
+  it 'initializes with the provided attributes' do
+    result = EvalIn::Result.new exitstatus:        123,
+                                language:          'the language',
+                                language_friendly: 'the friendly language',
+                                code:              'the code',
+                                output:            'the output',
+                                status:            'the status'
+    assert_result result,
+                  exitstatus:        123,
+                  language:          'the language',
+                  language_friendly: 'the friendly language',
+                  code:              'the code',
+                  output:            'the output',
+                  status:            'the status'
+  end
+
+  it 'uses sensible type-correct defaults for missing attributes' do
+    assert_result EvalIn::Result.new,
+                  exitstatus:        -1,
+                  language:          '',
+                  language_friendly: '',
+                  code:              '',
+                  output:            '',
+                  status:            '',
+                  url:               ''
+    assert_result EvalIn::Result.new(language:          nil,
+                                     language_friendly: nil,
+                                     code:              nil,
+                                     output:            nil,
+                                     status:            nil,
+                                     url:               nil),
+                  exitstatus:        -1,
+                  language:          '',
+                  language_friendly: '',
+                  code:              '',
+                  output:            '',
+                  status:            '',
+                  url:               ''
+  end
+
+  it 'doesn\'t mutate the input attributes' do
+    attributes = {status: 'OK'}
+    EvalIn::Result.new attributes
+    expect(attributes).to eq status: 'OK'
+  end
+
+  it 'logs extra attributes to stderr input' do
+    fake_error_stream = StringIO.new
+    EvalIn::Result.new a: 1, b: 2, stderr: fake_error_stream
+    expect(fake_error_stream.string).to eq "Unexpected attributes! [:a, :b]\n"
+  end
+
+  it 'defaults the error stream to $stderr' do
+    expect { EvalIn::Result.new a: 1, b: 2 }.to \
+      output("Unexpected attributes! [:a, :b]\n").to_stderr
+  end
+
+  it 'has an as_json representation which dumps all its keys' do
+    result = EvalIn::Result.new(language:          'l',
+                                language_friendly: 'lf',
+                                code:              'c',
+                                output:            'o',
+                                status:            's',
+                                url:               'u')
+    expect(result.as_json).to eq 'exitstatus'        => -1,
+                                 'language'          => 'l',
+                                 'language_friendly' => 'lf',
+                                 'code'              => 'c',
+                                 'output'            => 'o',
+                                 'status'            => 's',
+                                 'url'               => 'u'
+  end
+
+  it 'has a to_json that works correctly' do
+    result = EvalIn::Result.new(language:          'l',
+                                language_friendly: 'lf',
+                                code:              'c',
+                                output:            'o',
+                                status:            's',
+                                url:               'u')
+    after_json = JSON.parse(result.to_json)
+    expect(after_json).to eq 'exitstatus'        => -1,
+                             'language'          => 'l',
+                             'language_friendly' => 'lf',
+                             'code'              => 'c',
+                             'output'            => 'o',
+                             'status'            => 's',
+                             'url'               => 'u'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require 'eval_in'
+require 'webmock'
+WebMock.disable_net_connect!
+
+RSpec.configure do |config|
+  config.filter_run_excluding integration: true
+
+  config.include Module.new {
+    def assert_result(result, attributes)
+      attributes.each do |key, value|
+        expect(result.public_send key).to eq value
+      end
+    end
+
+    def success_status_regex
+      /OK \([\d.]+ sec real, [\d.]+ sec wall, \d MB, \d+ syscalls\)/
+    end
+  }
+
+  config.after do
+    WebMock.reset!
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eval_in
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Josh Cheek
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-06 00:00:00.000000000 Z
+date: 2014-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -79,8 +79,17 @@ files:
 - Readme.md
 - eval_in.gemspec
 - lib/eval_in.rb
-- lib/eval_in/version.rb
+- lib/eval_in/client.rb
+- lib/eval_in/constants.rb
+- lib/eval_in/http.rb
+- lib/eval_in/mock.rb
+- lib/eval_in/result.rb
+- spec/client_spec.rb
 - spec/eval_in_spec.rb
+- spec/http_spec.rb
+- spec/mock_spec.rb
+- spec/result_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/JoshCheek/eval_in
 licenses:
 - WTFPL
@@ -106,5 +115,10 @@ signing_key:
 specification_version: 4
 summary: Evaluates code (Ruby and others) safely by sending it to https://eval.in
 test_files:
+- spec/client_spec.rb
 - spec/eval_in_spec.rb
+- spec/http_spec.rb
+- spec/mock_spec.rb
+- spec/result_spec.rb
+- spec/spec_helper.rb
 has_rdoc: 

data/lib/eval_in/version.rb

@@ -1,3 +0,0 @@
-module EvalIn
-  VERSION = '0.1.6'
-end