eval_in 0.1.6 → 0.2.0

data/lib/eval_in/http.rb

@@ -0,0 +1,46 @@
+require 'uri'
+require 'net/http'
+require 'pathname'
+
+module EvalIn
+
+  # This module contains generic wrappers over net/http
+  # We can't just use Net::HTTP.get, b/c it doesn't use ssl on 1.9.3
+  # https://github.com/ruby/ruby/blob/v2_1_2/lib/net/http.rb#L478-479
+  # https://github.com/ruby/ruby/blob/v1_9_3_547/lib/net/http.rb#L454
+  module HTTP
+    extend self
+
+    def get_request(raw_url, user_agent)
+      generic_request_for raw_url:      raw_url,
+                          request_type: Net::HTTP::Get,
+                          user_agent:   user_agent
+    end
+
+    def post_request(raw_url, form_data, user_agent)
+      generic_request_for raw_url:      raw_url,
+                          request_type: Net::HTTP::Post,
+                          user_agent:   user_agent,
+                          form_data:    form_data
+    end
+
+    # stole this out of implementation for post_form https://github.com/ruby/ruby/blob/2afed6eceff2951b949db7ded8167a75b431bad6/lib/net/http.rb#L503
+    # can use this to view the request: http.set_debug_output $stdout
+    def generic_request_for(params)
+      uri                   = URI params.fetch(:raw_url)
+      path                  = uri.path
+      path                  = '/' if path.empty?
+      request               = params.fetch(:request_type).new(path)
+      request['User-Agent'] = params[:user_agent] if params.key? :user_agent
+      request.form_data     = params[:form_data]  if params.key? :form_data
+      request.basic_auth uri.user, uri.password   if uri.user
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: (uri.scheme == 'https')) { |http| http.request request }
+    end
+
+    def jsonify_url(url)
+      uri = URI(url)
+      uri.path = Pathname.new(uri.path).sub_ext('.json').to_s
+      uri.to_s
+    end
+  end
+end

data/lib/eval_in/mock.rb

@@ -0,0 +1,80 @@
+require 'open3'
+require 'tempfile'
+require 'eval_in'
+require 'eval_in/client'
+require 'eval_in/result'
+
+module EvalIn
+  class Mock
+    def initialize(options={})
+      @result          = options.fetch :result,          nil
+      @languages       = options.fetch :languages,       Hash.new
+      @on_call         = options.fetch(:on_call)         { lambda { |*args| @result || evaluate_with_tempfile(*args) } }
+      @on_fetch_result = options.fetch(:on_fetch_result) { lambda { |*args| @result || EvalIn.fetch_result(*args)    } }
+    end
+
+    def call(code, options={})
+      language_name = EvalIn::Client.language_or_error_from options
+      @on_call.call(code, options)
+    end
+
+    def fetch_result(raw_url, options={})
+      @on_fetch_result.call(raw_url, options)
+    end
+
+    private
+
+    def evaluate_with_tempfile(code, options={})
+      language_name = EvalIn::Client.language_or_error_from options
+      tempfile      = Tempfile.new 'EvalIn-mock'
+      tempfile.write code
+      tempfile.close
+      lang          = @languages.fetch language_name
+      program       = lang.fetch(:program)
+      args          = lang.fetch(:args, []) + [tempfile.path]
+      out, status = open_process_capture_out_and_error(program, args)
+      Result.new output:            out,
+                 exitstatus:        status.exitstatus,
+                 language:          language_name,
+                 language_friendly: language_name,
+                 code:              code,
+                 url:               'https://eval.in/207744.json',
+                 status:            'OK (0.072 sec real, 0.085 sec wall, 8 MB, 19 syscalls)'
+    ensure
+      tempfile.unlink if tempfile
+    end
+
+    def open_process_capture_out_and_error(program, args)
+      Open3.capture2e(program, *args)
+    end
+
+    # I legit tried for a couple of hours to get this to work on JRuby, this is attempt 1, it blows up b/c Kernel#spawn won't take in/out/err on JRuby
+    #   # Defining it myself since JRuby doesn't seem to implement Open3.capture2e correctly
+    #   # Implementation stolen and modified from numerous functions here:
+    #   #   https://github.com/ruby/ruby/blob/622f31be31b43429dfebe85e8f5bc5c92af5dd1f/lib/open3.rb#L318-351
+    #   def open_process_capture_out_and_error(program, args)
+    #     in_r,  in_w  = IO.pipe
+    #     out_r, out_w = IO.pipe
+    #     in_w.sync    = true
+    #     pid = spawn(program, *args, in: in_r, out: out_w, err: out_w)
+    #     in_r.close
+    #     out_w.close
+    #     output = out_r.read
+    #     Process.wait pid
+    #     [output, $?]
+    #   ensure
+    #     in_w.close
+    #     out_r.close
+    #   end
+    #
+    # This was attempt 2, it blows up b/c I cannot fucking figure out how to get the exit status
+    # def open_process_capture_out_and_error(program, args)
+    #   if IO.respond_to? :popen4
+    #     pid, stdin, stdout, stderr = IO.popen4('c:\ruby187\bin\ruby.exe')
+    #     [stdout.read, $?]
+    #   else
+    #     Open3.capture2e(program, *args)
+    #   end
+    # end
+  end
+end

data/lib/eval_in/result.rb

@@ -0,0 +1,38 @@
+require 'json'
+
+module EvalIn
+  # The data structure containing the final result
+  # its attributes default to null-objects for their given type
+  class Result
+    @attribute_names = [:exitstatus, :language, :language_friendly, :code, :output, :status, :url].freeze
+    attr_accessor *@attribute_names
+    class << self
+      attr_reader :attribute_names
+    end
+
+    def initialize(attributes={})
+      attributes = attributes.dup
+      self.exitstatus         = attributes.delete(:exitstatus)        || -1
+      self.language           = attributes.delete(:language)          || ""
+      self.language_friendly  = attributes.delete(:language_friendly) || ""
+      self.code               = attributes.delete(:code)              || ""
+      self.output             = attributes.delete(:output)            || ""
+      self.status             = attributes.delete(:status)            || ""
+      self.url                = attributes.delete(:url)               || ""
+      stderr                  = attributes.delete(:stderr)            || $stderr
+      stderr.puts "Unexpected attributes! #{attributes.keys.inspect}" if attributes.any?
+    end
+
+    # Returns representation of the result built out of JSON primitives (hash, string, int)
+    # This is useful for composing JSON structures and only rendering the JSON string at the end
+    def as_json
+      self.class.attribute_names.each_with_object Hash.new do |name, attributes|
+        attributes[name.to_s] = public_send name
+      end
+    end
+
+    def to_json
+      JSON.dump(as_json)
+    end
+  end
+end

data/spec/client_spec.rb

@@ -0,0 +1,195 @@
+# encoding: utf-8
+
+require 'spec_helper'
+RSpec.describe EvalIn::Client do
+  describe 'post_code' do
+    include WebMock::API
+
+    # ACTUAL RESPONSE:
+    #
+    # HTTP/1.1 302 Found\r
+    # Server: nginx/1.4.6 (Ubuntu)\r
+    # Date: Sun, 24 Aug 2014 05:57:17 GMT\r
+    # Content-Type: text/html;charset=utf-8\r
+    # Content-Length: 0\r
+    # Connection: keep-alive\r
+    # Location: https://eval.in/182584
+    # X-XSS-Protection: 1; mode=block\r
+    # X-Content-Type-Options: nosniff\r
+    # X-Frame-Options: SAMEORIGIN\r
+    # X-Runtime: 0.042154\r
+    # Strict-Transport-Security: max-age=31536000\r
+    # \r
+    def stub_eval_in(data=expected_data)
+      stub_request(:post, url)
+        .with(body: data)
+        .to_return(status: 302, headers: {'Location' => result_location})
+    end
+
+    def post_code(code, options)
+      EvalIn::Client.post_code code, options
+    end
+
+    let(:code)            { 'print "hello, #{gets}"' }
+    let(:stdin)           { "world" }
+    let(:language)        { "ruby/mri-1.9.3" }
+    let(:expected_data)   { {"utf8" => "√", "code" => code, "execute" => "on", "lang" => language, "input" => stdin} }
+    let(:result_location) { 'https://eval.in/182584' }
+    let(:url)             { "https://eval.in/" }
+
+    it 'posts the data to eval_in with utf8, execute on, and the code/language/input forwarded through' do
+      stub_eval_in expected_data
+      post_code code, stdin: stdin, language: language
+    end
+
+    it 'defaults the user agent to its gem homepage' do
+      stub_request(:post, url)
+        .with(headers: {'User-Agent' => 'http://rubygems.org/gems/eval_in'})
+        .to_return(status: 302, headers: {'Location' => result_location})
+      post_code code, language: language
+    end
+
+    it 'can add a context to the user agent' do
+      stub_request(:post, url)
+        .with(headers: {'User-Agent' => 'http://rubygems.org/gems/eval_in (some context)'})
+        .to_return(status: 302, headers: {'Location' => result_location})
+      post_code code, language: language, context: 'some context'
+    end
+
+    it 'returns the redirect location jsonified' do
+      stub_eval_in expected_data
+      result = post_code code, stdin: stdin, language: language
+      expect(result).to eq "#{result_location}.json"
+    end
+
+    it "Doesn't jsonify the redirect location if it already has a json suffix" do
+      result_location << '.json'
+      stub_eval_in expected_data
+      result = post_code code, stdin: stdin, language: language
+      expect(result).to eq result_location
+    end
+
+    it 'sets input to empty string if not provided' do
+      stub_eval_in expected_data.merge('input' => '')
+      post_code code, language: language
+    end
+
+    it 'raises an ArgumentError error if not given a language' do
+      expect { post_code code, {} }.to raise_error ArgumentError, /language/
+    end
+
+    it 'can override the url' do
+      url.replace "http://example.com"
+      stub_eval_in
+      post_code code, url: 'http://example.com', stdin: stdin, language: language
+    end
+
+    it 'supports basic http auth' do
+      url.replace "http://user:pass@example.com"
+      stub_eval_in
+      post_code code, url: 'http://user:pass@example.com', stdin: stdin, language: language
+    end
+
+    context 'when it gets a non-redirect' do
+      it 'informs user of language provided and languages known if language is unknown' do
+        stub_request(:post, "https://eval.in/").to_return(status: 406)
+        expect { post_code code, language: 'unknown-language' }.to \
+          raise_error EvalIn::RequestError, /unknown-language.*?ruby\/mri-2.1/m
+      end
+
+      it 'just bubbles the existing error up if it knows the language' do
+        stub_request(:post, "https://eval.in/").to_return(status: 406)
+        expect { post_code code, language: 'ruby/mri-2.1' }.to \
+          raise_error EvalIn::RequestError, /406/
+      end
+    end
+  end
+
+
+  describe 'fetch_result_json' do
+    include WebMock::API
+
+    def stub_eval_in(options={})
+      stub_request(:get,   options.fetch(:url))
+        .to_return(status: options.fetch(:status, 200),
+                   body:   options.fetch(:json_result, json_result))
+    end
+
+    def fetch_result_json(url)
+      EvalIn::Client.fetch_result_json url
+    end
+
+    let(:ruby_result) { {'lang' => 'some lang', 'lang_friendly' => 'some lang friendly', 'code' => 'some code', 'output' => 'some output', 'status' => 'some status'} }
+    let(:json_result) { JSON.dump ruby_result }
+
+    it 'queries the location, and inflates the json' do
+      stub_eval_in(url: "http://example.com/some-result.json")
+      result = fetch_result_json "http://example.com/some-result.json"
+      expect(result).to match hash_including(ruby_result)
+    end
+
+    it 'raises an error when it gets a non-200' do
+      stub_eval_in json_result: '', url: 'http://example.com'
+      expect { fetch_result_json "http://example.com" }.to \
+        raise_error EvalIn::ResultNotFound, %r(http://example.com)
+    end
+
+    it 'adds the url to the result' do
+      stub_eval_in url: 'http://example.com'
+      result = fetch_result_json 'http://example.com'
+      expect(result['url']).to eq 'http://example.com'
+    end
+  end
+
+
+  describe 'build_result' do
+    def build_result(response_json)
+      result = EvalIn::Client.build_result response_json
+    end
+
+    let(:language)          { 'some lang'          }
+    let(:language_friendly) { 'some lang friendly' }
+    let(:code)              { 'some code'          }
+    let(:output)            { 'some output'        }
+    let(:status)            { 'some status'        }
+    let(:url)               { 'some url'           }
+    let(:response_json)     { {'lang' => language, 'lang_friendly' => language_friendly, 'code' => code, 'output' => output, 'status' => status, 'url' => 'some url'} }
+
+    it 'returns a response for the given response json' do
+      result = build_result response_json
+      assert_result result,
+                    exitstatus:        0,
+                    language:          language,
+                    language_friendly: language_friendly,
+                    code:              code,
+                    output:            output,
+                    status:            status,
+                    url:               url
+    end
+
+    # exit:      https://eval.in/182586.json
+    # raise:     https://eval.in/182587.json
+    # in C:      https://eval.in/182588.json
+    # Forbidden: https://eval.in/182599.json
+    it 'sets the exit status to that of the program when it is available' do
+      result = build_result response_json.merge('status' => "Exited with error status 123")
+      expect(result.exitstatus).to eq 123
+    end
+
+    it 'sets the exit status to -1 when it is not available' do
+      result = build_result response_json.merge('status' => nil)
+      expect(result.exitstatus).to eq -1
+    end
+
+    it 'sets the exit status to 0 when the status does not imply a nonzero exit status' do
+      result = build_result response_json.merge('status' => 'OK (0.012 sec real, 0.013 sec wall, 7 MB, 22 syscalls)')
+      expect(result.exitstatus).to eq 0
+    end
+
+    it 'sets the exit status to 1 when there is an error' do
+      result = build_result response_json.merge('status' => 'Forbidden access to file `/usr/local/bin/gem')
+      expect(result.exitstatus).to eq 1
+    end
+  end
+
+end

data/spec/eval_in_spec.rb

@@ -1,398 +1,118 @@
 # encoding: utf-8
+require 'spec_helper'
 
-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
+RSpec.describe EvalIn do
+  describe 'integration tests', integration: true do
+    around do |spec|
+      WebMock.allow_net_connect!
+      spec.call
+      WebMock.disable_net_connect!
     end
-  }
-
-  config.after do
-    WebMock.reset!
-  end
-end
-
-RSpec.describe EvalIn, integration: true do
-  around do |spec|
-    WebMock.allow_net_connect!
-    spec.call
-    WebMock.disable_net_connect!
-  end
-
-  let(:context) { 'eval_in integration test' }
-
-  it 'evaluates Ruby code through eval.in' do
-    result = EvalIn.call 'print "hello, #{gets}"', stdin: "world", language: "ruby/mri-2.1", context: context
-    expect(result.exitstatus       ).to eq 0
-    expect(result.language         ).to eq "ruby/mri-2.1"
-    expect(result.language_friendly).to eq "Ruby — MRI 2.1"
-    expect(result.code             ).to eq 'print "hello, #{gets}"'
-    expect(result.output           ).to eq "hello, world"
-    expect(result.status           ).to match /OK \([\d.]+ sec real, [\d.]+ sec wall, \d MB, \d+ syscalls\)/
-    expect(result.url              ).to match %r(https://eval.in/\d+.json)
-  end
-
-  it 'fetches previous results from eval.in' do
-    result = EvalIn.fetch_result "https://eval.in/147.json"
-    expect(result.exitstatus       ).to eq 0
-    expect(result.language         ).to eq "ruby/mri-1.9.3"
-    expect(result.language_friendly).to eq "Ruby — MRI 1.9.3"
-    expect(result.code             ).to eq %'class Greeter\r\n  def initialize(name)\r\n    @name = name\r\n  end\r\n\r\n  def greet\r\n    puts \"Hello \#{@name}!\"\r\n  end\r\nend\r\n\r\ngreeter = Greeter.new \"Charlie\"\r\ngreeter.greet'
-    expect(result.output           ).to eq "Hello Charlie!\n"
-    expect(result.status           ).to match /OK \([\d.]+ sec real, [\d.]+ sec wall, \d MB, \d+ syscalls\)/
-    expect(result.url              ).to match %r(https://eval.in/147.json)
-  end
-
-  it 'is in sync with known languages' do
-    # iffy solution, but it's simple and works,
-    # Rexml might get taken out of stdlib, so is more likely than this regex to fail in the future,
-    # and I don't want to add dep on Nokogiri (w/ libxml & libxslt) where a small regex works adequately
-    current_known_languages = EvalIn.get_request('https://eval.in', context)
-                                    .body
-                                    .each_line
-                                    .map { |line| line[/option.*?value="([^"]+)"/, 1] }
-                                    .compact
-    expect(EvalIn::KNOWN_LANGUAGES).to eq current_known_languages
-  end
-end
-
-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
-
-
-RSpec.describe 'post_code' do
-  include WebMock::API
-
-  # ACTUAL RESPONSE:
-  #
-  # HTTP/1.1 302 Found\r
-  # Server: nginx/1.4.6 (Ubuntu)\r
-  # Date: Sun, 24 Aug 2014 05:57:17 GMT\r
-  # Content-Type: text/html;charset=utf-8\r
-  # Content-Length: 0\r
-  # Connection: keep-alive\r
-  # Location: https://eval.in/182584
-  # X-XSS-Protection: 1; mode=block\r
-  # X-Content-Type-Options: nosniff\r
-  # X-Frame-Options: SAMEORIGIN\r
-  # X-Runtime: 0.042154\r
-  # Strict-Transport-Security: max-age=31536000\r
-  # \r
-  def stub_eval_in(data=expected_data)
-    stub_request(:post, url)
-      .with(body: data)
-      .to_return(status: 302, headers: {'Location' => result_location})
-  end
-
-  let(:code)            { 'print "hello, #{gets}"' }
-  let(:stdin)           { "world" }
-  let(:language)        { "ruby/mri-1.9.3" }
-  let(:expected_data)   { {"utf8" => "√", "code" => code, "execute" => "on", "lang" => language, "input" => stdin} }
-  let(:result_location) { 'https://eval.in/182584' }
-  let(:url)             { "https://eval.in/" }
-
-  it 'posts the data to eval_in with utf8, execute on, and the code/language/input forwarded through' do
-    stub_eval_in expected_data
-    EvalIn.post_code code, stdin: stdin, language: language
-  end
-
-  it 'defaults the user agent to its gem homepage' do
-    stub_request(:post, url)
-      .with(headers: {'User-Agent' => 'http://rubygems.org/gems/eval_in'})
-      .to_return(status: 302, headers: {'Location' => result_location})
-    EvalIn.post_code code, language: language
-  end
-
-  it 'can add a context to the user agent' do
-    stub_request(:post, url)
-      .with(headers: {'User-Agent' => 'http://rubygems.org/gems/eval_in (some context)'})
-      .to_return(status: 302, headers: {'Location' => result_location})
-    EvalIn.post_code code, language: language, context: 'some context'
-  end
-
-  it 'returns the redirect location jsonified' do
-    stub_eval_in expected_data
-    result = EvalIn.post_code code, stdin: stdin, language: language
-    expect(result).to eq "#{result_location}.json"
-  end
-
-  it "Doesn't jsonify the redirect location if it already has a json suffix" do
-    result_location << '.json'
-    stub_eval_in expected_data
-    result = EvalIn.post_code code, stdin: stdin, language: language
-    expect(result).to eq result_location
-  end
-
-  it 'sets input to empty string if not provided' do
-    stub_eval_in expected_data.merge('input' => '')
-    EvalIn.post_code code, language: language
-  end
-
-  it 'raises an ArgumentError error if not given a language' do
-    expect { EvalIn.post_code code, {} }.to raise_error ArgumentError, /language/
-  end
-
-  it 'can override the url' do
-    url.replace "http://example.com"
-    stub_eval_in
-    EvalIn.post_code code, url: 'http://example.com', stdin: stdin, language: language
-  end
-
-  it 'supports basic http auth' do
-    url.replace "http://user:pass@example.com"
-    stub_eval_in
-    EvalIn.post_code code, url: 'http://user:pass@example.com', stdin: stdin, language: language
-  end
-
-  context 'when it gets a non-redirect' do
-    it 'informs user of language provided and languages known if language is unknown' do
-      stub_request(:post, "https://eval.in/").to_return(status: 406)
-      expect { EvalIn.post_code code, language: 'unknown-language' }.to \
-        raise_error EvalIn::RequestError, /unknown-language.*?ruby\/mri-2.1/m
+    let(:context) { 'eval_in integration test' }
+
+    example 'using .call to evaluate Ruby code' do
+      result = EvalIn.call 'print "hello, #{gets}"', stdin: "world", language: "ruby/mri-2.1", context: context
+      expect(result.exitstatus       ).to eq 0
+      expect(result.language         ).to eq "ruby/mri-2.1"
+      expect(result.language_friendly).to eq "Ruby — MRI 2.1"
+      expect(result.code             ).to eq 'print "hello, #{gets}"'
+      expect(result.output           ).to eq "hello, world"
+      expect(result.status           ).to match success_status_regex
+      expect(result.url              ).to match %r(https://eval.in/\d+.json)
     end
 
-    it 'just bubbles the existing error up if it knows the language' do
-      stub_request(:post, "https://eval.in/").to_return(status: 406)
-      expect { EvalIn.post_code code, language: 'ruby/mri-2.1' }.to \
-        raise_error EvalIn::RequestError, /406/
+    example 'using .fetch_result to fetch a known result from eval.in' do
+      result = EvalIn.fetch_result "https://eval.in/147.json"
+      expect(result.exitstatus       ).to eq 0
+      expect(result.language         ).to eq "ruby/mri-1.9.3"
+      expect(result.language_friendly).to eq "Ruby — MRI 1.9.3"
+      expect(result.code             ).to eq %'class Greeter\r\n  def initialize(name)\r\n    @name = name\r\n  end\r\n\r\n  def greet\r\n    puts \"Hello \#{@name}!\"\r\n  end\r\nend\r\n\r\ngreeter = Greeter.new \"Charlie\"\r\ngreeter.greet'
+      expect(result.output           ).to eq "Hello Charlie!\n"
+      expect(result.status           ).to match success_status_regex
+      expect(result.url              ).to match %r(https://eval.in/147.json)
     end
-  end
-end
-
-
-
-RSpec.describe 'fetch_result_json' do
-  include WebMock::API
-
-  def stub_eval_in(options={})
-    stub_request(:get,   options.fetch(:url))
-      .to_return(status: options.fetch(:status, 200),
-                 body:   options.fetch(:json_result, json_result))
-  end
-
-  let(:ruby_result) { {'lang' => 'some lang', 'lang_friendly' => 'some lang friendly', 'code' => 'some code', 'output' => 'some output', 'status' => 'some status'} }
-  let(:json_result) { JSON.dump ruby_result }
-
-  it 'queries the location, and inflates the json' do
-    stub_eval_in(url: "http://example.com/some-result.json")
-    result = EvalIn.fetch_result_json "http://example.com/some-result.json"
-    expect(result).to match hash_including(ruby_result)
-  end
-
-  it 'raises an error when it gets a non-200' do
-    stub_eval_in json_result: '', url: 'http://example.com'
-    expect { EvalIn.fetch_result_json "http://example.com" }.to \
-      raise_error EvalIn::ResultNotFound, %r(http://example.com)
-  end
-
-  it 'adds the url to the result' do
-    stub_eval_in url: 'http://example.com'
-    result = EvalIn.fetch_result_json 'http://example.com'
-    expect(result['url']).to eq 'http://example.com'
-  end
-end
-
 
-RSpec.describe 'build_result' do
-  let(:language)          { 'some lang'          }
-  let(:language_friendly) { 'some lang friendly' }
-  let(:code)              { 'some code'          }
-  let(:output)            { 'some output'        }
-  let(:status)            { 'some status'        }
-  let(:url)               { 'some url'           }
-  let(:response_json)     { {'lang' => language, 'lang_friendly' => language_friendly, 'code' => code, 'output' => output, 'status' => status, 'url' => 'some url'} }
-
-  it 'returns a response for the given response json' do
-    result = EvalIn.build_result response_json
-    assert_result result,
-                  exitstatus:        0,
-                  language:          language,
-                  language_friendly: language_friendly,
-                  code:              code,
-                  output:            output,
-                  status:            status,
-                  url:               url
+    example 'ensure the KNOWN_LANGUAGES are up to date' do
+      # iffy solution, but it's simple and works,
+      # Rexml might get taken out of stdlib, so is more likely than this regex to fail in the future,
+      # and I don't want to add dep on Nokogiri (w/ libxml & libxslt) where a small regex works adequately
+      current_known_languages = EvalIn::HTTP.get_request('https://eval.in', context)
+                                            .body
+                                            .each_line
+                                            .map { |line| line[/option.*?value="([^"]+)"/, 1] }
+                                            .compact
+      expect(EvalIn::KNOWN_LANGUAGES).to eq current_known_languages
+    end
   end
 
-  # exit:      https://eval.in/182586.json
-  # raise:     https://eval.in/182587.json
-  # in C:      https://eval.in/182588.json
-  # Forbidden: https://eval.in/182599.json
-  it 'sets the exit status to that of the program when it is available' do
-    result = EvalIn.build_result response_json.merge('status' => "Exited with error status 123")
-    expect(result.exitstatus).to eq 123
-  end
 
-  it 'sets the exit status to -1 when it is not available' do
-    result = EvalIn.build_result response_json.merge('status' => nil)
-    expect(result.exitstatus).to eq -1
-  end
 
-  it 'sets the exit status to 0 when the status does not imply a nonzero exit status' do
-    result = EvalIn.build_result response_json.merge('status' => 'OK (0.012 sec real, 0.013 sec wall, 7 MB, 22 syscalls)')
-    expect(result.exitstatus).to eq 0
-  end
+  describe 'toplevel methods' do
+    include WebMock::API
 
-  it 'sets the exit status to 1 when there is an error' do
-    result = EvalIn.build_result response_json.merge('status' => 'Forbidden access to file `/usr/local/bin/gem')
-    expect(result.exitstatus).to eq 1
-  end
-end
+    let(:ruby_result) { {'lang' => 'some lang', 'lang_friendly' => 'some lang friendly', 'code' => 'some code', 'output' => 'some output', 'status' => 'some status'} }
+    let(:json_result) { JSON.dump ruby_result }
 
+    def stub_eval_in(url, options={})
+      stub_request(:get, url)
+        .with(headers: {'User-Agent' => options.fetch(:user_agent, 'http://rubygems.org/gems/eval_in')})
+        .to_return(status: 200, body: json_result)
+    end
 
-RSpec.describe 'fetch_result' do
-  include WebMock::API
+    describe '.call' do
+      it 'posts code through eval.in, following the redirect to return an EvalIn::Result' do
+        post_url   = 'http://example.com/fake_post_endpoint'
+        get_url    = 'http://example.com/fake_get_endpoint.json'
+        context    = 'SOME CONTEXT'
+        user_agent = "http://rubygems.org/gems/eval_in (#{context})"
 
-  def stub_eval_in(url, options={})
-    stub_request(:get, url)
-      .with(headers: {'User-Agent' => options.fetch(:user_agent, 'http://rubygems.org/gems/eval_in')})
-      .to_return(status: 200, body: json_result)
-  end
+        # stub the post, verifies the context and url got passed through, redirects to the get
+        stub_request(:post, post_url)
+          .with(headers: {'User-Agent' => user_agent})
+          .to_return(status: 302, headers: {'location' => get_url}, body: json_result)
 
-  let(:ruby_result) { {'lang' => 'some lang', 'lang_friendly' => 'some lang friendly', 'code' => 'some code', 'output' => 'some output', 'status' => 'some status'} }
-  let(:json_result) { JSON.dump ruby_result }
-
-  it 'wraps fetch_result_json and build_result' do
-    url = 'https://eval.in/1.json'
-    stub_eval_in url
-    result = EvalIn.fetch_result url
-    assert_result result,
-                  exitstatus:        0,
-                  language:          ruby_result['lang'],
-                  language_friendly: ruby_result['lang_friendly'],
-                  code:              ruby_result['code'],
-                  output:            ruby_result['output'],
-                  status:            ruby_result['status'],
-                  url:               url
-  end
+        # stub the get to return the mock result
+        stub_eval_in(get_url, user_agent: user_agent) 
 
-  it 'jsonifies the url if it isn\'t already' do
-    stub_eval_in 'https://eval.in/1.json'
-    expect(EvalIn.fetch_result('https://eval.in/1').url).to      eq 'https://eval.in/1.json'
-    expect(EvalIn.fetch_result('https://eval.in/1.json').url).to eq 'https://eval.in/1.json'
-  end
+        # make the request, posting the code, following the redirect, parsing the json, turning it into a Result
+        result = EvalIn.call 'print "hello, #{gets}"', language: "ruby/mri-2.1", context: context, url: post_url
 
-  it 'can take a context for the user agent' do
-    stub_eval_in 'https://eval.in/1.json', user_agent: 'http://rubygems.org/gems/eval_in (c)'
-    expect(EvalIn.fetch_result('https://eval.in/1', context: 'c').url).to eq 'https://eval.in/1.json'
-  end
-end
+        # Just verify that one of the expected values is there,
+        # all the specifics are better tested in .fetch_result and the integration tests
+        # this is just a quick wiring test with a "data looks about right"
+        expect(result.language).to eq ruby_result['lang']
+      end
+    end
 
 
-RSpec.describe 'jsonify_url' do
-  def assert_transforms(initial_url, expected_url)
-    actual_url = EvalIn.jsonify_url(initial_url)
-    expect(actual_url).to eq expected_url
-  end
+    describe '.fetch_result' do
+      it 'fetches the json at the provided url and returns a result' do
+        url = 'https://eval.in/1.json'
+        stub_eval_in url
+        result = EvalIn.fetch_result url
+        assert_result result,
+                      exitstatus:        0,
+                      language:          ruby_result['lang'],
+                      language_friendly: ruby_result['lang_friendly'],
+                      code:              ruby_result['code'],
+                      output:            ruby_result['output'],
+                      status:            ruby_result['status'],
+                      url:               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'
+      it 'jsonifies the url if it isn\'t already' do
+        stub_eval_in 'https://eval.in/1.json'
+        expect(EvalIn.fetch_result('https://eval.in/1').url).to      eq 'https://eval.in/1.json'
+        expect(EvalIn.fetch_result('https://eval.in/1.json').url).to eq 'https://eval.in/1.json'
+      end
 
-    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 'can take a context for the user agent' do
+        stub_eval_in 'https://eval.in/1.json', user_agent: 'http://rubygems.org/gems/eval_in (c)'
+        expect(EvalIn.fetch_result('https://eval.in/1', context: 'c').url).to eq 'https://eval.in/1.json'
+      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