elasticity 1.5 → 2.0

data/lib/elasticity/support/conditional_raise.rb

@@ -0,0 +1,23 @@
+module Elasticity
+
+  module ConditionalRaising
+
+    def raise_if(conditional, error_class, message)
+      raise error_class, message if conditional
+    end
+
+    def raise_unless(conditional, error_class, message)
+      raise error_class, message unless conditional
+    end
+
+  end
+
+end
+
+module Kernel
+  include Elasticity::ConditionalRaising
+end
+
+class Object
+  include Kernel
+end

data/lib/elasticity/version.rb

@@ -1,3 +1,3 @@
 module Elasticity
-  VERSION = "1.5"
+  VERSION = "2.0"
 end

data/spec/lib/elasticity/aws_request_spec.rb

@@ -1,72 +1,180 @@
-require 'spec_helper'
-
 describe Elasticity::AwsRequest do
 
-  describe ".aws_escape" do
-    it "should escape according to Amazon's rules" do
-      # Don't encode reserved characters
-      Elasticity::AwsRequest.aws_escape("foo-_.~bar").should == "foo-_.~bar"
-      # Encode as %20, not as +
-      Elasticity::AwsRequest.aws_escape("foo bar").should == "foo%20bar"
-      # Percent encode all other characters with %XY, where X and Y are hex characters 0-9 and uppercase A-F.
-      Elasticity::AwsRequest.aws_escape("foo$&+,/:;=?@bar").should == "foo%24%26%2B%2C%2F%3A%3B%3D%3F%40bar"
-    end
+  before do
+    Time.stub(:now).and_return(Time.at(1302461096))
+  end
+
+  subject do
+    Elasticity::AwsRequest.new('access', 'secret')
   end
 
-  describe "#sign_params" do
-    before do
-      Time.stub(:now).and_return(Time.at(1302461096))
+  its(:access_key) { should == 'access' }
+  its(:secret_key) { should == 'secret' }
+
+  describe '#host' do
+
+    context 'when the region is not specified' do
+      its(:host) { should == 'elasticmapreduce.amazonaws.com' }
     end
-    it "should sign according to Amazon's rules" do
-      request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_access_key")
-      signed_params = request.send(:sign_params, {}, "GET", "example.com", "/")
-      signed_params.should == "AWSAccessKeyId=aws_access_key_id&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=2011-04-10T18%3A44%3A56.000Z&Signature=jVLfPS056dNmjpCcikBnPmRHJNZ8YGaI7zdmHWUk658%3D"
+
+    context 'when the region is specified' do
+      let(:request_with_region) do
+        Elasticity::AwsRequest.new('_', '_', {:region => 'us-west-1'})
+      end
+      it 'should incorporate the region into the hostname' do
+        request_with_region.host.should == 'elasticmapreduce.us-west-1.amazonaws.com'
+      end
     end
+
   end
 
-  describe "#aws_emr_request" do
-    before do
-      Time.stub(:now).and_return(Time.at(1302461096))
+  describe '#protocol' do
+
+    context 'when :secure is not specified' do
+      let(:default_request) { Elasticity::AwsRequest.new('_', '_') }
+      it 'should be https by default' do
+        default_request.protocol.should == 'https'
+      end
     end
 
-    describe "options" do
+    context 'when :secure is specified' do
 
-      describe "region" do
-        context "when :region is specified" do
-          it "should request against that region" do
-            request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_access_key",
-              :region => "eu-west-1")
-            RestClient.should_receive(:get).with(/elasticmapreduce\.eu\-west\-1\.amazonaws\.com/)
-            request.aws_emr_request({})
-          end
-        end
-        context "when :region is not specified" do
-          it "should use the default request url" do
-            request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_access_key")
-            RestClient.should_receive(:get).with(/elasticmapreduce\.amazonaws\.com/)
-            request.aws_emr_request({})
-          end
+      context 'when :secure is truthy' do
+        let(:secure_request) { Elasticity::AwsRequest.new('_', '_', {:secure => true}) }
+        it 'should be https' do
+          secure_request.protocol.should == 'https'
         end
       end
 
-      describe ":secure" do
-        context "when :secure is specified" do
-          it "should use the value to determine the request type" do
-            request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_access_key",
-              :secure => false)
-            RestClient.should_receive(:get).with(/^http:/)
-            request.aws_emr_request({})
-          end
+      context 'when :secure is falsey' do
+        let(:insecure_request) { Elasticity::AwsRequest.new('_', '_', {:secure => false}) }
+        it 'should be http' do
+          insecure_request.protocol.should == 'http'
         end
-        context "when :secure is not specified" do
-          it "should default to secure connection" do
-            request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_access_key")
-            RestClient.should_receive(:get).with(/^https:/)
-            request.aws_emr_request({})
-          end
+      end
+
+    end
+
+  end
+
+  describe '#sign_params' do
+    it 'should sign according to AWS rules' do
+      signed_params = subject.send(:sign_params, {})
+      signed_params.should == 'AWSAccessKeyId=access&SignatureMethod=HmacSHA256&SignatureVersion=2&Timestamp=2011-04-10T18%3A44%3A56.000Z&Signature=QwQIiizWrfvWuLNnzmCMfaeXFfh9IQTvOix5MNVTh2s%3D'
+    end
+  end
+
+  describe '#submit' do
+
+    let(:request) do
+      Elasticity::AwsRequest.new('_', '_').tap do |r|
+        r.instance_variable_set(:@host, 'HOSTNAME')
+        r.instance_variable_set(:@protocol, 'PROTOCOL')
+      end
+    end
+
+    it 'should POST a properly assembled request' do
+      ruby_params = {}
+      aws_params = {}
+      Elasticity::AwsRequest.should_receive(:convert_ruby_to_aws).with(ruby_params).and_return(ruby_params)
+      request.should_receive(:sign_params).with(aws_params).and_return('SIGNED_PARAMS')
+      RestClient.should_receive(:post).with('PROTOCOL://HOSTNAME', 'SIGNED_PARAMS', :content_type => 'application/x-www-form-urlencoded; charset=utf-8')
+      request.submit(ruby_params)
+    end
+
+    context 'when there is an EMR error with the request' do
+      let(:error_message) { 'ERROR_MESSAGE' }
+      let(:error_xml) do
+        <<-ERROR
+          <ErrorResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
+            <Error>
+              <Message>#{error_message}</Message>
+            </Error>
+          </ErrorResponse>
+        ERROR
+      end
+      let(:error) do
+        RestClient::BadRequest.new.tap do |error|
+          error.stub(:http_body => error_xml)
         end
       end
 
+      it 'should raise an Argument error with the body of the error' do
+        RestClient.should_receive(:post).and_raise(error)
+        expect {
+          request.submit({})
+        }.to raise_error(ArgumentError, error_message)
+      end
+    end
+
+  end
+
+  describe '#==' do
+    let(:same_object) { subject }
+    let(:same_values) { Elasticity::AwsRequest.new('access', 'secret', {}) }
+    let(:diff_type) { Object.new }
+
+    it { should == same_object }
+    it { should == same_values }
+    it { should_not == diff_type }
+
+    it 'should be false on deep comparison' do
+      {
+        :@access_key => '_',
+        :@secret_key => '_',
+        :@options => {:foo => :bar}
+      }.each do |variable, value|
+        other = Elasticity::AwsRequest.new('aws_access_key_id', 'aws_secret_access_key', {})
+        other.instance_variable_set(variable, value)
+        subject.should_not == other
+      end
+    end
+
+  end
+
+  describe '.convert_ruby_to_aws' do
+    it 'should convert the params' do
+      add_jobflow_steps_params = {
+        :job_flow_id => 'j-1',
+        :steps => [
+          {
+            :action_on_failure => 'CONTINUE',
+            :name => 'First New Job Step',
+            :hadoop_jar_step => {
+              :args => ['arg1', 'arg2', 'arg3',],
+              :jar => 'first_step.jar',
+              :main_class => 'first_class.jar'
+            }
+          },
+            {
+              :action_on_failure => 'CANCEL_AND_WAIT',
+              :name => 'Second New Job Step',
+              :hadoop_jar_step => {
+                :args => ['arg4', 'arg5', 'arg6',],
+                :jar => 'second_step.jar',
+                :main_class => 'second_class.jar'
+              }
+            }
+        ]
+      }
+      expected_result = {
+        'JobFlowId' => 'j-1',
+        'Steps.member.1.Name' => 'First New Job Step',
+        'Steps.member.1.ActionOnFailure' => 'CONTINUE',
+        'Steps.member.1.HadoopJarStep.Jar' => 'first_step.jar',
+        'Steps.member.1.HadoopJarStep.MainClass' => 'first_class.jar',
+        'Steps.member.1.HadoopJarStep.Args.member.1' => 'arg1',
+        'Steps.member.1.HadoopJarStep.Args.member.2' => 'arg2',
+        'Steps.member.1.HadoopJarStep.Args.member.3' => 'arg3',
+        'Steps.member.2.Name' => 'Second New Job Step',
+        'Steps.member.2.ActionOnFailure' => 'CANCEL_AND_WAIT',
+        'Steps.member.2.HadoopJarStep.Jar' => 'second_step.jar',
+        'Steps.member.2.HadoopJarStep.MainClass' => 'second_class.jar',
+        'Steps.member.2.HadoopJarStep.Args.member.1' => 'arg4',
+        'Steps.member.2.HadoopJarStep.Args.member.2' => 'arg5',
+        'Steps.member.2.HadoopJarStep.Args.member.3' => 'arg6'
+      }
+      Elasticity::AwsRequest.send(:convert_ruby_to_aws, add_jobflow_steps_params).should == expected_result
     end
   end
 

data/spec/lib/elasticity/custom_jar_step_spec.rb

@@ -0,0 +1,59 @@
+describe Elasticity::CustomJarStep do
+
+  subject do
+    Elasticity::CustomJarStep.new('jar')
+  end
+
+  it { should be_a Elasticity::JobFlowStep }
+
+  its(:name) { should == 'Elasticity Custom Jar Step (jar)' }
+  its(:jar) { should == 'jar' }
+  its(:arguments) { should == [] }
+  its(:action_on_failure) { should == 'TERMINATE_JOB_FLOW' }
+
+  describe '#to_aws_step' do
+
+    it { should respond_to(:to_aws_step).with(1).argument }
+
+    context 'when there are no arguments provided' do
+      let(:cjs_with_no_args) { Elasticity::CustomJarStep.new('jar') }
+
+      it 'should convert to aws step format' do
+        cjs_with_no_args.to_aws_step(Elasticity::JobFlow.new('access', 'secret')).should == {
+          :action_on_failure => 'TERMINATE_JOB_FLOW',
+          :hadoop_jar_step => {
+            :jar => 'jar'
+          },
+          :name => 'Elasticity Custom Jar Step (jar)'
+        }
+      end
+    end
+
+    context 'when there are arguments provided' do
+      let(:cjs_with_args) do
+        Elasticity::CustomJarStep.new('jar').tap do |cjs|
+          cjs.arguments = ['arg1', 'arg2']
+        end
+      end
+
+      it 'should convert to aws step format' do
+        cjs_with_args.to_aws_step(Elasticity::JobFlow.new('access', 'secret')).should == {
+          :action_on_failure => 'TERMINATE_JOB_FLOW',
+          :hadoop_jar_step => {
+            :jar => 'jar',
+            :args => ['arg1', 'arg2',],
+          },
+          :name => 'Elasticity Custom Jar Step (jar)'
+        }
+      end
+    end
+
+  end
+
+  describe '.requires_installation?' do
+    it 'should not require installation' do
+      Elasticity::CustomJarStep.requires_installation?.should be_false
+    end
+  end
+
+end

data/spec/lib/elasticity/emr_spec.rb

@@ -1,879 +1,348 @@
-require 'spec_helper'
-
 describe Elasticity::EMR do
 
-  describe "#add_instance_groups" do
-
-    describe "integration happy path" do
-
-      context "when properly specified" do
-        use_vcr_cassette "add_instance_groups/one_group_successful", :record => :none
-        it "should add the instance groups" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          instance_group_config = {
-            :instance_count => 1,
-            :instance_role => "TASK",
-            :instance_type => "m1.small",
-            :market => "ON_DEMAND",
-            :name => "Go Canucks Go!"
-          }
-          instance_group_ids = emr.add_instance_groups("j-OALI7TZTQMHX", [instance_group_config])
-          instance_group_ids.should == ["ig-2GOVEN6HVJZID"]
-        end
-      end
-
-      context "when improperly specified" do
-        use_vcr_cassette "add_instance_groups/one_group_unsuccessful", :record => :none
-        it "should add the instance groups" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          instance_group_config = {
-            :bid_price => 0,
-            :instance_count => 1,
-            :instance_role => "TASK",
-            :instance_type => "m1.small",
-            :market => "ON_DEMAND",
-            :name => "Go Canucks Go!"
-          }
-          lambda {
-            emr.add_instance_groups("j-19WDDS68ZUENP", [instance_group_config])
-          }.should raise_error(ArgumentError, "Task instance group already exists in the job flow, cannot add more task groups")
-        end
-      end
+  subject do
+    Elasticity::EMR.new('ACCESS', 'SECRET')
+  end
 
-    end
+  its(:aws_request) { should == Elasticity::AwsRequest.new('ACCESS', 'SECRET', {}) }
 
-    describe "unit tests" do
-
-      context "when multiple instance groups are specified" do
-        before do
-          @add_instance_groups_xml = <<-ADD_GROUPS
-            <AddInstanceGroupsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-              <AddInstanceGroupsResult>
-                <JobFlowId>j-OALI7TZTQMHX</JobFlowId>
-                <InstanceGroupIds>
-                  <member>ig-1</member>
-                  <member>ig-2</member>
-                  <member>ig-3</member>
-                </InstanceGroupIds>
-              </AddInstanceGroupsResult>
-            </AddInstanceGroupsResponse>
-          ADD_GROUPS
-        end
+  describe '#add_instance_groups' do
 
-        it "should iterate over them and send the correct params to AWS" do
-          instance_group_configs = [
-            {:instance_type=>"m1.small", :instance_role=>"CORE", :market=>"ON_DEMAND", :instance_count=>1, :name=>"Go Canucks Go!", :bid_price=>0},
-              {:instance_type=>"m1.small", :instance_role=>"CORE", :market=>"ON_DEMAND", :instance_count=>1, :name=>"Go Canucks Go!", :bid_price=>0},
-          ]
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).with({
-            "Operation" => "AddInstanceGroups",
-            "InstanceGroups.member.1.Name"=>"Go Canucks Go!",
-            "InstanceGroups.member.1.InstanceRole"=>"CORE",
-            "InstanceGroups.member.1.InstanceCount"=>1,
-            "InstanceGroups.member.1.BidPrice"=>0,
-            "InstanceGroups.member.1.InstanceType"=>"m1.small",
-            "InstanceGroups.member.1.Market"=>"ON_DEMAND",
-            "InstanceGroups.member.2.Name"=>"Go Canucks Go!",
-            "InstanceGroups.member.2.InstanceRole"=>"CORE",
-            "InstanceGroups.member.2.InstanceCount"=>1,
-            "InstanceGroups.member.2.BidPrice"=>0,
-            "InstanceGroups.member.2.InstanceType"=>"m1.small",
-            "InstanceGroups.member.2.Market"=>"ON_DEMAND",
-            "JobFlowId"=>"j-19WDDS68ZUENP"
-          })
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          emr.add_instance_groups("j-19WDDS68ZUENP", instance_group_configs)
-        end
+    it 'should send the correct params to AWS' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'AddInstanceGroups',
+        :job_flow_id => 'JOBFLOW_ID',
+        :instance_groups => ['INSTANCE_GROUP_CONFIGS']
+      })
+      subject.add_instance_groups('JOBFLOW_ID', ['INSTANCE_GROUP_CONFIGS'])
+    end
 
-        it "should return an array of the instance groups created" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return(@add_instance_groups_xml)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          emr.add_instance_groups("", []).should == ["ig-1", "ig-2", "ig-3"]
-        end
+    describe 'return values' do
+      let(:aws_response) do
+        <<-XML
+          <AddInstanceGroupsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
+            <AddInstanceGroupsResult>
+              <JobFlowId>j-OALI7TZTQMHX</JobFlowId>
+              <InstanceGroupIds>
+                <member>ig-1</member>
+                <member>ig-2</member>
+                <member>ig-3</member>
+              </InstanceGroupIds>
+            </AddInstanceGroupsResult>
+          </AddInstanceGroupsResponse>
+        XML
+      end
+
+      it 'should return an array of the new instance groups IDs' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(aws_response)
+        subject.add_instance_groups('', []).should == ['ig-1', 'ig-2', 'ig-3']
       end
+    end
 
-      context "when a block is provided" do
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return("AWS XML")
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          xml_result = nil
-          emr.add_instance_groups("", []) do |xml|
-            xml_result = xml
-          end
-          xml_result.should == "AWS XML"
+    context 'when a block is given' do
+      let(:result) { 'RESULT' }
+      it 'should yield the submission results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.add_instance_groups('', []) do |xml|
+          xml.should == 'RESULT'
         end
       end
-
     end
 
   end
 
-  describe "#add_jobflow_steps" do
-
-    describe "integration happy path" do
-      use_vcr_cassette "add_jobflow_steps/add_multiple_steps", :record => :none
-
-      before do
-        @setup_pig_step = {
-          :action_on_failure => "TERMINATE_JOB_FLOW",
-          :hadoop_jar_step => {
-            :args => [
-              "s3://elasticmapreduce/libs/pig/pig-script",
-                "--base-path",
-                "s3://elasticmapreduce/libs/pig/",
-                "--install-pig"
-            ],
-            :jar => "s3://elasticmapreduce/libs/script-runner/script-runner.jar"
-          },
-          :name => "Setup Pig"
-        }
-        @emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        @jobflow_id = @emr.run_job_flow({
-          :name => "Elasticity Test Flow (EMR Pig Script)",
-          :instances => {
-            :ec2_key_name => "sharethrough-dev",
-            :instance_count => 2,
-            :master_instance_type => "m1.small",
-            :slave_instance_type => "m1.small",
-          },
-          :steps => [@setup_pig_step]
-        })
-      end
-
-      it "should add a job flow step to the specified job flow" do
-        @emr.add_jobflow_steps(@jobflow_id, {
-          :steps => [
-            @setup_pig_step.merge(:name => "Setup Pig 2"),
-              @setup_pig_step.merge(:name => "Setup Pig 3")
-          ]
-        })
-        jobflow = @emr.describe_jobflows.select { |jf| jf.jobflow_id = @jobflow_id }.first
-        jobflow.steps.map(&:name).should == ["Setup Pig", "Setup Pig 2", "Setup Pig 3"]
-      end
+  describe '#add_jobflow_steps' do
 
+    it 'should add the specified steps to the job flow' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'AddJobFlowSteps',
+        :job_flow_id => 'JOBFLOW_ID',
+        :steps => ['_']
+      })
+      subject.add_jobflow_steps('JOBFLOW_ID', {:steps => ['_']})
     end
 
-    describe "unit tests" do
-
-      it "should add the specified steps to the job flow" do
-        aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        aws_request.should_receive(:aws_emr_request).with({
-          "Operation" => "AddJobFlowSteps",
-          "JobFlowId" => "j-1",
-          "Steps.member.1.Name" => "Step 1",
-          "Steps.member.1.ActionOnFailure" => "TERMINATE_JOB_FLOW",
-          "Steps.member.1.HadoopJarStep.Jar" => "jar1",
-          "Steps.member.1.HadoopJarStep.Args.member.1" => "arg1-1",
-          "Steps.member.1.HadoopJarStep.Args.member.2" => "arg1-2",
-          "Steps.member.2.Name" => "Step 2",
-          "Steps.member.2.ActionOnFailure" => "CONTINUE",
-          "Steps.member.2.HadoopJarStep.Jar" => "jar2",
-          "Steps.member.2.HadoopJarStep.Args.member.1" => "arg2-1",
-          "Steps.member.2.HadoopJarStep.Args.member.2" => "arg2-2",
-        })
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        emr.add_jobflow_steps("j-1", {
-          :steps => [
-            {
-              :action_on_failure => "TERMINATE_JOB_FLOW",
-              :name => "Step 1",
-              :hadoop_jar_step => {
-                :args => ["arg1-1", "arg1-2"],
-                :jar => "jar1",
-              }
-            },
-              {
-                :action_on_failure => "CONTINUE",
-                :name => "Step 2",
-                :hadoop_jar_step => {
-                  :args => ["arg2-1", "arg2-2"],
-                  :jar => "jar2",
-                }
-              }
-          ]
-        })
-      end
-
-      context "when there is an error" do
-        before do
-          @error_message = "2 validation errors detected: Value null at 'steps' failed to satisfy constraint: Member must not be null; Value null at 'jobFlowId' failed to satisfy constraint: Member must not be null"
-          @error_xml = <<-ERROR
-            <ErrorResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-              <Error>
-                <Message>#{@error_message}</Message>
-              </Error>
-            </ErrorResponse>
-          ERROR
-        end
-
-        it "should raise an ArgumentError with the error message" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          @exception = RestClient::BadRequest.new
-          @exception.should_receive(:http_body).and_return(@error_xml)
-          aws_request.should_receive(:aws_emr_request).and_raise(@exception)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          lambda {
-            emr.add_jobflow_steps("", {})
-          }.should raise_error(ArgumentError, @error_message)
-        end
-      end
-
-      context "when a block is given" do
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return("xml_response")
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          xml_result = nil
-          emr.add_jobflow_steps("", {}) do |xml|
-            xml_result = xml
-          end
-          xml_result.should == "xml_response"
+    context 'when a block is given' do
+      let(:result) { 'RESULT' }
+      it 'should yield the submission results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.add_jobflow_steps('', {}) do |xml|
+          xml.should == 'RESULT'
         end
       end
-
-
     end
 
   end
 
-  describe "#describe_jobflows" do
+  describe '#describe_jobflows' do
 
-    describe "integration happy path" do
-      use_vcr_cassette "describe_jobflows/all_jobflows", :record => :none
-      it "should return the names of all running job flows" do
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        jobflows = emr.describe_jobflows
-        jobflows.map(&:name).should == ["WM+RS", "Interactive Audience Hive Test", "Audience (Hive)", "Audience Reporting"]
-        jobflows.map(&:jobflow_id).should == ["j-1MZ5TVWFJRSKN", "j-38EU2XZQP9KJ4", "j-2TDCVGEEHOFI9", "j-NKKQ429D858I"]
-        jobflows.map(&:state).should == ["TERMINATED", "TERMINATED", "TERMINATED", "TERMINATED"]
-      end
+    let(:describe_jobflows_xml) do
+      <<-XML
+        <DescribeJobFlowsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
+          <DescribeJobFlowsResult>
+            <JobFlows>
+              <member>
+                <ExecutionStatusDetail>
+                  <CreationDateTime>2011-04-04T17:41:51Z</CreationDateTime>
+                  <State>TERMINATED</State>
+                </ExecutionStatusDetail>
+                <JobFlowId>j-p</JobFlowId>
+                <Name>Pig Job</Name>
+              </member>
+              <member>
+                <ExecutionStatusDetail>
+                  <State>TERMINATED</State>
+                  <CreationDateTime>2011-04-04T17:41:51Z</CreationDateTime>
+                </ExecutionStatusDetail>
+                <JobFlowId>j-h</JobFlowId>
+                <Name>Hive Job</Name>
+              </member>
+            </JobFlows>
+          </DescribeJobFlowsResult>
+        </DescribeJobFlowsResponse>
+      XML
     end
 
-    describe "unit tests" do
-      before do
-        @describe_jobflows_xml = <<-JOBFLOWS
-          <DescribeJobFlowsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-            <DescribeJobFlowsResult>
-              <JobFlows>
-                <member>
-                  <ExecutionStatusDetail>
-                    <CreationDateTime>2011-04-04T17:41:51Z</CreationDateTime>
-                    <State>TERMINATED</State>
-                  </ExecutionStatusDetail>
-                  <JobFlowId>j-p</JobFlowId>
-                  <Name>Pig Job</Name>
-                </member>
-                <member>
-                  <ExecutionStatusDetail>
-                    <State>TERMINATED</State>
-                    <CreationDateTime>2011-04-04T17:41:51Z</CreationDateTime>
-                  </ExecutionStatusDetail>
-                  <JobFlowId>j-h</JobFlowId>
-                  <Name>Hive Job</Name>
-                </member>
-              </JobFlows>
-            </DescribeJobFlowsResult>
-          </DescribeJobFlowsResponse>
-        JOBFLOWS
-      end
+    it 'should return an array of properly populated JobFlowStatusES' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(describe_jobflows_xml)
+      jobflow_statuses = subject.describe_jobflows
+      jobflow_statuses.map(&:name).should == ['Pig Job', 'Hive Job']
+      jobflow_statuses.map(&:class).should == [Elasticity::JobFlowStatus, Elasticity::JobFlowStatus]
+    end
 
-      it "should return the names of all running job flows" do
-        aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-        aws_request.should_receive(:aws_emr_request).with({"Operation" => "DescribeJobFlows"}).and_return(@describe_jobflows_xml)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-        jobflows = emr.describe_jobflows
-        jobflows.map(&:name).should == ["Pig Job", "Hive Job"]
-      end
+    it 'should describe all jobflows' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'DescribeJobFlows'
+      })
+      subject.describe_jobflows
+    end
 
-      it "should accept additional parameters" do
-        aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-        aws_request.should_receive(:aws_emr_request).with({"Operation" => "DescribeJobFlows","CreatedBefore" => "2011-10-04"}).and_return(@describe_jobflows_xml)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-        emr.describe_jobflows(:CreatedBefore => "2011-10-04")
+    context 'when additional parameters are provided' do
+      it 'should pass them through' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+          :CreatedBefore => '2011-10-04',
+          :operation => 'DescribeJobFlows'
+        })
+        subject.describe_jobflows(:CreatedBefore => '2011-10-04')
       end
+    end
 
-      context "when a block is provided" do
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return("describe!")
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          xml_result = nil
-          emr.describe_jobflows do |xml|
-            xml_result = xml
-          end
-          xml_result.should == "describe!"
+    context 'when a block is given' do
+      let(:result) { 'RESULT' }
+      it 'should yield the submission results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.describe_jobflows do |xml|
+          xml.should == 'RESULT'
         end
       end
     end
 
   end
 
-  describe "#describe_jobflow" do
-    before do
-      @describe_jobflows_xml = <<-JOBFLOWS
+  describe '#describe_jobflow' do
+
+    let(:describe_jobflows_xml) {
+      <<-XML
         <DescribeJobFlowsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
           <DescribeJobFlowsResult>
             <JobFlows>
               <member>
+                <JobFlowId>j-3UN6WX5RRO2AG</JobFlowId>
+                <Name>The One Job Flow</Name>
                 <ExecutionStatusDetail>
                   <State>TERMINATED</State>
                   <CreationDateTime>2011-04-04T17:41:51Z</CreationDateTime>
                 </ExecutionStatusDetail>
-                <JobFlowId>j-3UN6WX5RRO2AG</JobFlowId>
-                <Name>The One Job Flow</Name>
               </member>
             </JobFlows>
           </DescribeJobFlowsResult>
         </DescribeJobFlowsResponse>
-      JOBFLOWS
-    end
+      XML
+    }
 
-    it "should ask AWS about the specified job flow" do
-      aws_request = Elasticity::AwsRequest.new("","")
-      aws_request.should_receive(:aws_emr_request).with({
-        "Operation" => "DescribeJobFlows",
-        "JobFlowIds.member.1" => "j-3UN6WX5RRO2AG"
+    it 'should describe the specified jobflow' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'DescribeJobFlows',
+        :job_flow_ids => ['j-3UN6WX5RRO2AG']
       })
-      Elasticity::AwsRequest.stub(:new).and_return(aws_request)
-      emr = Elasticity::EMR.new("", "")
-      emr.describe_jobflow("j-3UN6WX5RRO2AG")
-    end
-
-    context "when the job flow ID exists" do
-      it "should return a JobFlow" do
-        aws_request = Elasticity::AwsRequest.new("","")
-        aws_request.stub(:aws_emr_request).with({
-          "Operation" => "DescribeJobFlows",
-          "JobFlowIds.member.1" => "j-3UN6WX5RRO2AG"
-        }).and_return(@describe_jobflows_xml)
-        Elasticity::AwsRequest.stub(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new("", "")
-        jobflow = emr.describe_jobflow("j-3UN6WX5RRO2AG")
-        jobflow.jobflow_id.should == "j-3UN6WX5RRO2AG"
-      end
+      subject.describe_jobflow('j-3UN6WX5RRO2AG')
     end
 
-    context "when there is an error" do
-      before do
-        @error_xml = <<-ERROR
-          <ErrorResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-            <Error>
-              <Message>Specified job flow ID not valid</Message>
-            </Error>
-          </ErrorResponse>
-        ERROR
-      end
-
-      it "should raise an ArgumentError with the error message" do
-        aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-        @exception = RestClient::BadRequest.new
-        @exception.should_receive(:http_body).and_return(@error_xml)
-        aws_request.should_receive(:aws_emr_request).and_raise(@exception)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-        lambda {
-          emr.describe_jobflow("bad_jobflow_id")
-        }.should raise_error(ArgumentError, "Specified job flow ID not valid")
-      end
+    it 'should return a properly populated JobFlowStatus' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(describe_jobflows_xml)
+      jobflow_status = subject.describe_jobflow('_')
+      jobflow_status.should be_a Elasticity::JobFlowStatus
+      jobflow_status.jobflow_id.should == 'j-3UN6WX5RRO2AG'
     end
 
-    context "when a block is provided" do
-      it "should yield to the block" do
-        aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-        aws_request.should_receive(:aws_emr_request).and_return("describe!")
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-        xml_result = nil
-        emr.describe_jobflow("_") do |xml|
-          xml_result = xml
+    context 'when a block is given' do
+      let(:result) { 'RESULT' }
+      it 'should yield the submission results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.describe_jobflow('') do |xml|
+          xml.should == 'RESULT'
         end
-        xml_result.should == "describe!"
       end
     end
   end
 
-  describe "#modify_instance_groups" do
+  describe '#modify_instance_groups' do
 
-    describe "integration happy path" do
-      context "when the instance group exists" do
-        use_vcr_cassette "modify_instance_groups/set_instances_to_3", :record => :none
-        it "should terminate the specified jobflow" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          instance_group_config = {"ig-2T1HNUO61BG3O" => 2}
-          emr.modify_instance_groups(instance_group_config)
-        end
-      end
+    it 'should modify the specified instance groups' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'ModifyInstanceGroups',
+        :instance_groups => [{
+          :instance_group_id => 'ig-2T1HNUO61BG3O',
+          :instance_count => 2
+        }]
+      })
+      subject.modify_instance_groups({'ig-2T1HNUO61BG3O' => 2})
     end
 
-    describe "unit tests" do
-
-      context "when the instance group exists" do
-        it "should modify the specified instance group" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).with({
-            "Operation" => "ModifyInstanceGroups",
-            "InstanceGroups.member.1.InstanceGroupId" => "ig-1",
-            "InstanceGroups.member.1.InstanceCount" => 2
-          })
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          emr.modify_instance_groups({"ig-1" => 2})
+    context 'when a block is given' do
+      let(:result) { '_' }
+      it 'should yield the submission results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.modify_instance_groups({}) do |xml|
+          xml.should == '_'
         end
       end
-
-      context "when a block is given" do
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return("xml result!")
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          xml_result = nil
-          emr.modify_instance_groups({"ig-1" => 2}) do |xml|
-            xml_result = xml
-          end
-          xml_result.should == "xml result!"
-        end
-      end
-
-
-      context "when there is an error" do
-
-        before do
-          @error_message = "1 validation error detected: Value null at 'instanceGroups.1.member.instanceCount' failed to satisfy constraint: Member must not be null"
-          @error_xml = <<-ERROR
-            <ErrorResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-              <Error>
-                <Message>#{@error_message}</Message>
-              </Error>
-            </ErrorResponse>
-          ERROR
-        end
-
-        it "should raise an ArgumentError with the error message" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          @exception = RestClient::BadRequest.new
-          @exception.should_receive(:http_body).and_return(@error_xml)
-          aws_request.should_receive(:aws_emr_request).and_raise(@exception)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          lambda {
-            emr.modify_instance_groups({"ig-1" => 2})
-          }.should raise_error(ArgumentError, @error_message)
-        end
-
-      end
-
     end
 
   end
 
-  describe "#run_jobflow" do
-
-    describe "integration happy path" do
-
-      context "when the job flow is properly specified" do
-        use_vcr_cassette "run_jobflow/word_count", :record => :none
-        it "should start the specified job flow" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          jobflow_id = emr.run_job_flow({
-            :name => "Elasticity Test Flow (EMR Pig Script)",
-            :instances => {
-              :ec2_key_name => "sharethrough-dev",
-              :hadoop_version => "0.20",
-              :instance_count => 2,
-              :master_instance_type => "m1.small",
-              :placement => {
-                :availability_zone => "us-east-1a"
-              },
-              :slave_instance_type => "m1.small",
-            },
-            :steps => [
-              {
-                :action_on_failure => "TERMINATE_JOB_FLOW",
-                :hadoop_jar_step => {
-                  :args => [
-                    "s3://elasticmapreduce/libs/pig/pig-script",
-                      "--base-path",
-                      "s3://elasticmapreduce/libs/pig/",
-                      "--install-pig"
-                  ],
-                  :jar => "s3://elasticmapreduce/libs/script-runner/script-runner.jar"
-                },
-                :name => "Setup Pig"
-              },
-                {
-                  :action_on_failure => "TERMINATE_JOB_FLOW",
-                  :hadoop_jar_step => {
-                    :args => [
-                      "s3://elasticmapreduce/libs/pig/pig-script",
-                        "--run-pig-script",
-                        "--args",
-                        "-p",
-                        "INPUT=s3n://elasticmapreduce/samples/pig-apache/input",
-                        "-p",
-                        "OUTPUT=s3n://slif-elasticity/pig-apache/output/2011-04-19",
-                        "s3n://elasticmapreduce/samples/pig-apache/do-reports.pig"
-                    ],
-                    :jar => "s3://elasticmapreduce/libs/script-runner/script-runner.jar"
-                  },
-                  :name => "Run Pig Script"
-                }
-            ]
-          })
-          jobflow_id.should == "j-G6N5HA528AD4"
-        end
-      end
+  describe '#run_jobflow' do
+
+    it 'should start the specified job flow' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'RunJobFlow',
+        :jobflow_params => '_'
+      })
+      subject.run_job_flow({:jobflow_params => '_'})
     end
 
-    describe "unit tests" do
-      it "should return the job flow ID of the new job" do
-        run_jobflow_response = <<-RESPONSE
+    describe 'jobflow response handling' do
+      let(:jobflow_xml_response) do
+        <<-XML
           <RunJobFlowResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
             <RunJobFlowResult>
-              <JobFlowId>j-N500G8Y8U7ZQ</JobFlowId>
+              <JobFlowId>j-G6N5HA528AD4</JobFlowId>
             </RunJobFlowResult>
             <ResponseMetadata>
-              <RequestId>a6dddf4c-6a49-11e0-b6c0-e9580d1f7304</RequestId>
+              <RequestId>b22f4aea-6a4b-11e0-9ddc-a168e244afdb</RequestId>
             </ResponseMetadata>
           </RunJobFlowResponse>
-        RESPONSE
-        aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        aws_request.should_receive(:aws_emr_request).and_return(run_jobflow_response)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        jobflow_id = emr.run_job_flow({})
-        jobflow_id.should == "j-N500G8Y8U7ZQ"
-      end
-
-      it "should run the specified job flow" do
-        aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        aws_request.should_receive(:aws_emr_request).with({
-          "Operation" => "RunJobFlow",
-          "Name" => "Job flow name",
-          "Instances.MasterInstanceType" => "m1.small",
-          "Instances.Placement.AvailabilityZone" => "us-east-1a",
-          "Steps.member.1.Name" => "Streaming Job",
-          "Steps.member.1.ActionOnFailure" => "TERMINATE_JOB_FLOW",
-          "Steps.member.1.HadoopJarStep.Jar" => "/home/hadoop/contrib/streaming/hadoop-streaming.jar",
-          "Steps.member.1.HadoopJarStep.Args.member.1" => "-input",
-          "Steps.member.1.HadoopJarStep.Args.member.2" => "s3n://elasticmapreduce/samples/wordcount/input"
-        })
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        emr.run_job_flow({
-          :name => "Job flow name",
-          :instances => {
-            :master_instance_type => "m1.small",
-            :placement => {
-              :availability_zone => "us-east-1a"
-            }
-          },
-          :steps => [
-            {
-              :action_on_failure => "TERMINATE_JOB_FLOW",
-              :name => "Streaming Job",
-              :hadoop_jar_step => {
-                :args => ["-input", "s3n://elasticmapreduce/samples/wordcount/input"],
-                :jar => "/home/hadoop/contrib/streaming/hadoop-streaming.jar",
-              }
-            }
-          ]
-        })
+        XML
       end
 
-      context "when there is an error" do
-        before do
-          @error_message = "1 validation error detected: Value null at 'instanceGroups.1.member.instanceCount' failed to satisfy constraint: Member must not be null"
-          @error_xml = <<-ERROR
-            <ErrorResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-              <Error>
-                <Message>#{@error_message}</Message>
-              </Error>
-            </ErrorResponse>
-          ERROR
-        end
-
-        it "should raise an ArgumentError with the error message" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          @exception = RestClient::BadRequest.new
-          @exception.should_receive(:http_body).and_return(@error_xml)
-          aws_request.should_receive(:aws_emr_request).and_raise(@exception)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          lambda {
-            emr.run_job_flow({})
-          }.should raise_error(ArgumentError, @error_message)
-        end
+      it 'should return the ID of the running job flow' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(jobflow_xml_response)
+        subject.run_job_flow({}).should == 'j-G6N5HA528AD4'
       end
+    end
 
-      context "when a block is given" do
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return("jobflow_id!")
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          xml_result = nil
-          emr.run_job_flow({}) do |xml|
-            xml_result = xml
-          end
-          xml_result.should == "jobflow_id!"
+    context 'when a block is given' do
+      let(:result) { '_' }
+      it 'should yield the submission results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.run_job_flow({}) do |xml|
+          xml.should == '_'
         end
       end
     end
 
   end
 
-  describe "#terminate_jobflows" do
+  describe '#terminate_jobflows' do
 
-    describe "integration happy path" do
-      context "when the job flow exists" do
-        use_vcr_cassette "terminate_jobflows/one_jobflow", :record => :none
-        it "should terminate the specified jobflow" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          emr.terminate_jobflows("j-1MZ5TVWFJRSKN")
-        end
-      end
+    it 'should terminate the specific jobflow' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+        :operation => 'TerminateJobFlows',
+        :job_flow_ids => ['j-1']
+      })
+      subject.terminate_jobflows('j-1')
     end
 
-    describe "unit tests" do
-
-      context "when the jobflow exists" do
-        before do
-          @terminate_jobflows_xml = <<-RESPONSE
-            <TerminateJobFlowsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-              <ResponseMetadata>
-                <RequestId>2690d7eb-ed86-11dd-9877-6fad448a8419</RequestId>
-              </ResponseMetadata>
-            </TerminateJobFlowsResponse>
-          RESPONSE
-        end
-        it "should terminate the specific jobflow" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).with({
-            "Operation" => "TerminateJobFlows",
-            "JobFlowIds.member.1" => "j-1"
-          }).and_return(@terminate_jobflows_xml)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          emr.terminate_jobflows("j-1")
-        end
-      end
-
-      context "when the jobflow does not exist" do
-        it "should raise an ArgumentError" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_raise(RestClient::BadRequest)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          lambda {
-            emr.terminate_jobflows("invalid_jobflow_id")
-          }.should raise_error(ArgumentError)
-        end
-      end
-
-      context "when a block is given" do
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-          aws_request.should_receive(:aws_emr_request).and_return("terminated!")
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-          xml_result = nil
-          emr.terminate_jobflows("j-1") do |xml|
-            xml_result = xml
-          end
-          xml_result.should == "terminated!"
+    context 'when a block is given' do
+      let(:result) { '_' }
+      it 'should yield the termination results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.terminate_jobflows('j-1') do |xml|
+          xml.should == '_'
         end
       end
-
     end
-  end
-
-  describe "#set_termination_protection" do
-
-    describe "integration happy path" do
-
-      context "when protecting multiple job flows" do
-        use_vcr_cassette "set_termination_protection/protect_multiple_job_flows", :record => :none
-        it "should protect the specified job flows" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          emr.set_termination_protection(["j-1B4D1XP0C0A35", "j-1YG2MYL0HVYS5"], true)
-        end
-      end
 
-      context "when specifying a job flow that doesn't exist" do
-        use_vcr_cassette "set_termination_protection/nonexistent_job_flows", :record => :none
-        it "should have an error" do
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          lambda {
-            emr.set_termination_protection(["j-1B4D1XP0C0A35", "j-2"], true)
-          }.should raise_error(ArgumentError, "Specified job flow ID not valid")
-        end
-      end
+  end
 
-    end
+  describe '#set_termination_protection' do
 
-    describe "unit tests" do
-      it "should enable protection on the specified job flows" do
-        aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        aws_request.should_receive(:aws_emr_request).with({
-          "Operation" => "SetTerminationProtection",
-          "JobFlowIds.member.1" => "jobflow1",
-          "JobFlowIds.member.2" => "jobflow2",
-          "TerminationProtected" => true
+    context 'when protection is enabled' do
+      it 'should enable protection on the specified jobflows' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+          :operation => 'SetTerminationProtection',
+          :termination_protected => true,
+          :job_flow_ids => ['jobflow1', 'jobflow2']
         })
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        emr.set_termination_protection(["jobflow1", "jobflow2"], true)
+        subject.set_termination_protection(['jobflow1', 'jobflow2'], true)
       end
+    end
 
-      it "should disable protection on the specified job flows" do
-        aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        aws_request.should_receive(:aws_emr_request).with({
-          "Operation" => "SetTerminationProtection",
-          "JobFlowIds.member.1" => "jobflow1",
-          "JobFlowIds.member.2" => "jobflow2",
-          "TerminationProtected" => false
+    context 'when protection is disabled' do
+      it 'should disable protection on the specified jobflows' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+          :operation => 'SetTerminationProtection',
+          :termination_protected => false,
+          :job_flow_ids => ['jobflow1', 'jobflow2']
         })
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        emr.set_termination_protection(["jobflow1", "jobflow2"], false)
+        subject.set_termination_protection(['jobflow1', 'jobflow2'], false)
       end
+    end
 
-      it "should enable protection when not specified" do
-        aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        aws_request.should_receive(:aws_emr_request).with({
-          "Operation" => "SetTerminationProtection",
-          "JobFlowIds.member.1" => "jobflow1",
-          "JobFlowIds.member.2" => "jobflow2",
-          "TerminationProtected" => true
+    context 'when protection is not specified' do
+      it 'should enable protection on the specified jobflows' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).with({
+          :operation => 'SetTerminationProtection',
+          :termination_protected => true,
+          :job_flow_ids => ['jobflow1', 'jobflow2']
         })
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        emr.set_termination_protection(["jobflow1", "jobflow2"])
+        subject.set_termination_protection(['jobflow1', 'jobflow2'])
       end
+    end
 
-      context "when a block is given" do
-        before do
-          @xml_response = <<-RESPONSE
-            <SetTerminationProtectionResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-              <ResponseMetadata>
-                <RequestId>755ebe8a-6923-11e0-a9c2-c126f1bb4493</RequestId>
-              </ResponseMetadata>
-            </SetTerminationProtectionResponse>
-          RESPONSE
-        end
-        it "should yield the XML result" do
-          aws_request = Elasticity::AwsRequest.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-          aws_request.should_receive(:aws_emr_request).and_return(@xml_response)
-          emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-          xml = nil
-          emr.set_termination_protection([]) do |aws_response|
-            xml = aws_response
-          end
-          xml.should == @xml_response
+    context 'when a block is given' do
+      let(:result) { '_' }
+      it 'should yield the termination results' do
+        Elasticity::AwsRequest.any_instance.should_receive(:submit).and_return(result)
+        subject.set_termination_protection([]) do |xml|
+          xml.should == '_'
         end
       end
     end
 
   end
 
-  describe "#direct" do
-
-    describe "integration happy path" do
-      use_vcr_cassette "direct/terminate_jobflow", :record => :none
-      it "should terminate the specified jobflow" do
-        emr = Elasticity::EMR.new(AWS_ACCESS_KEY_ID, AWS_SECRET_KEY)
-        params = {
-          "Operation" => "TerminateJobFlows",
-          "JobFlowIds.member.1" => "j-1MZ5TVWFJRSKN"
-        }
-        emr.direct(params)
-      end
-    end
+  describe '#direct' do
+    let(:params) { {:foo => 'bar'} }
 
-    describe "unit tests" do
-      before do
-        @terminate_jobflows_xml = <<-RESPONSE
-          <TerminateJobFlowsResponse xmlns="http://elasticmapreduce.amazonaws.com/doc/2009-03-31">
-            <ResponseMetadata>
-              <RequestId>2690d7eb-ed86-11dd-9877-6fad448a8419</RequestId>
-            </ResponseMetadata>
-          </TerminateJobFlowsResponse>
-        RESPONSE
-      end
-      it "should pass through directly to the request" do
-        aws_request = Elasticity::AwsRequest.new("aws_access_key_id", "aws_secret_key")
-        aws_request.should_receive(:aws_emr_request).with({
-          "Operation" => "TerminateJobFlows",
-          "JobFlowIds.member.1" => "j-1"
-        }).and_return(@terminate_jobflows_xml)
-        Elasticity::AwsRequest.should_receive(:new).and_return(aws_request)
-        emr = Elasticity::EMR.new("aws_access_key_id", "aws_secret_key")
-        params = {
-          "Operation" => "TerminateJobFlows",
-          "JobFlowIds.member.1" => "j-1"
-        }
-        emr.direct(params).should == @terminate_jobflows_xml
-      end
+    it 'should pass through directly to the request and return the results of the request' do
+      Elasticity::AwsRequest.any_instance.should_receive(:submit).with(params).and_return('RESULT')
+      subject.direct(params).should == 'RESULT'
     end
   end
 
-  describe ".convert_ruby_to_aws" do
-    it "should convert the params" do
-      add_jobflow_steps_params = {
-        :job_flow_id => "j-1",
-        :steps => [
-          {
-            :action_on_failure => "CONTINUE",
-            :name => "First New Job Step",
-            :hadoop_jar_step => {
-              :args => ["arg1", "arg2", "arg3",],
-              :jar => "first_step.jar",
-              :main_class => "first_class.jar"
-            }
-          },
-            {
-              :action_on_failure => "CANCEL_AND_WAIT",
-              :name => "Second New Job Step",
-              :hadoop_jar_step => {
-                :args => ["arg4", "arg5", "arg6",],
-                :jar => "second_step.jar",
-                :main_class => "second_class.jar"
-              }
-            }
-        ]
-      }
-      expected_result = {
-        "JobFlowId" => "j-1",
-        "Steps.member.1.Name" => "First New Job Step",
-        "Steps.member.1.ActionOnFailure" => "CONTINUE",
-        "Steps.member.1.HadoopJarStep.Jar" => "first_step.jar",
-        "Steps.member.1.HadoopJarStep.MainClass" => "first_class.jar",
-        "Steps.member.1.HadoopJarStep.Args.member.1" => "arg1",
-        "Steps.member.1.HadoopJarStep.Args.member.2" => "arg2",
-        "Steps.member.1.HadoopJarStep.Args.member.3" => "arg3",
-        "Steps.member.2.Name" => "Second New Job Step",
-        "Steps.member.2.ActionOnFailure" => "CANCEL_AND_WAIT",
-        "Steps.member.2.HadoopJarStep.Jar" => "second_step.jar",
-        "Steps.member.2.HadoopJarStep.MainClass" => "second_class.jar",
-        "Steps.member.2.HadoopJarStep.Args.member.1" => "arg4",
-        "Steps.member.2.HadoopJarStep.Args.member.2" => "arg5",
-        "Steps.member.2.HadoopJarStep.Args.member.3" => "arg6"
-      }
-      Elasticity::EMR.send(:convert_ruby_to_aws, add_jobflow_steps_params).should == expected_result
+  describe '#==' do
+    let(:emr1) { Elasticity::EMR.new('ACCESS1', 'SECRET1') }
+    let(:emr2) { Elasticity::EMR.new('ACCESS2', 'SECRET2') }
+
+    let(:same_object) { emr1 }
+    let(:same_values) { Elasticity::EMR.new('ACCESS1', 'SECRET1') }
+    let(:diff_type) { Object.new }
+
+    it 'should pass comparison checks' do
+      emr1.should == same_object
+      emr1.should == same_values
+      emr1.should_not == diff_type
     end
   end