squall 1.0.2 → 1.1.0

data/spec/squall/virtual_machine_spec.rb

@@ -2,10 +2,9 @@ require 'spec_helper'
 
 describe Squall::VirtualMachine do
   before(:each) do
-    default_config
     @virtual_machine = Squall::VirtualMachine.new
-    @valid = {:label => 'testmachine', :hypervisor_id => 5, :hostname => 'testmachine', :memory => 512, :cpus => 1,
-              :cpu_shares => 10, :primary_disk_size => 10}
+    @valid = {:label => 'testmachine', :hostname => 'testmachine', :memory => 512, :cpus => 1,
+              :cpu_shares => 10, :primary_disk_size => 10, :template_id => 1}
     @keys = ["monthly_bandwidth_used", "cpus", "label", "created_at", "operating_system_distro",
       "cpu_shares", "operating_system", "template_id", "allowed_swap", "local_remote_access_port",
       "memory", "updated_at", "allow_resize_without_reboot", "recovery_mode", "hypervisor_id", "id",
@@ -52,54 +51,48 @@ describe Squall::VirtualMachine do
       requires_attr(:label) { @virtual_machine.create }
     end
 
-    it "requires hypervisor_id" do
-      requires_attr(:hypervisor_id) { @virtual_machine.create(:label => @valid[:label]) }
-    end
-
     it "requires hostname" do
       requires_attr(:hostname) {
-        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id])
+        @virtual_machine.create(:label => @valid[:label])
       }
     end
 
     it "requires memory" do
       requires_attr(:memory) {
-        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname])
+        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname])
       }
     end
 
     it "requires cpus" do
       requires_attr(:cpus) {
-        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname],
+        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname],
                                 :memory => @valid[:memory])
       }
     end
 
     it "requires cpu_shares" do
       requires_attr(:cpu_shares) {
-        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname],
+        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname],
                                 :memory => @valid[:memory], :cpus => @valid[:cpu_shares])
       }
     end
 
     it "requires primary_disk_size" do
       requires_attr(:primary_disk_size) {
-        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id],
-                                :hostname => @valid[:hostname], :memory => @valid[:memory], :cpus => @valid[:cpu_shares],
+        @virtual_machine.create(:label => @valid[:label], :hostname => @valid[:hostname], 
+                                :memory => @valid[:memory], :cpus => @valid[:cpu_shares],
                                 :cpu_shares => @valid[:cpu_shares])
       }
     end
 
     it "raises error on unknown params" do
       expect {
-        @virtual_machine.create(:label => @valid[:label],  :hypervisor_id => @valid[:hypervisor_id], :hostname => @valid[:hostname],
-                                :memory => @valid[:memory], :cpus => @valid[:cpus], :cpu_shares => @valid[:cpu_shares], :what => 'what')
-      }.to raise_error(ArgumentError, 'Missing required params: primary_disk_size')
+        @virtual_machine.create(@valid.merge(:what => 'what'))
+      }.to raise_error(ArgumentError, 'Unknown params: what')
     end
 
     it "allows all optional params" do
-      optional = [:cpu_shares,
-                  :swap_disk_size,
+      optional = [:swap_disk_size,
                   :primary_network_id,
                   :required_automatic_backup,
                   :rate_limit,
@@ -108,20 +101,22 @@ describe Squall::VirtualMachine do
                   :admin_note,
                   :note,
                   :allowed_hot_migrate,
-                  :template_id,
+                  :hypervisor_id,
                   :initial_root_password
       ]
 
       @virtual_machine.should_receive(:request).exactly(optional.size).times.and_return Hash.new('virtual_machine' => [])
-      optional.each do |k,v|
-        @virtual_machine.create(@valid.merge(k.to_sym => v))
+      optional.each do |param|
+        @virtual_machine.create(@valid.merge(param => "test"))
       end
     end
 
     it "creates a virtual_machine" do
-      virtual_machine = @virtual_machine.create(@valid)
-      @valid.each do |k,v|
-        virtual_machine[k].should == @valid[k.to_s]
+      pending "broken in OnApp (triggering the Network Interfaces error): see README (and update when fixed)" do 
+        virtual_machine = @virtual_machine.create(@valid)
+        @valid.each do |k,v|
+          virtual_machine[k].should == @valid[k.to_s]
+        end
       end
     end
   end
@@ -140,20 +135,19 @@ describe Squall::VirtualMachine do
     end
 
     it "raises error on unknown params" do
-      expect { @virtual_machine.build(1, :asdf => 1) }.to raise_error(ArgumentError, 'Unknown params: asdf')
+      expect { @virtual_machine.build(1, :template_id => 1, :asdf => 1) }.to raise_error(ArgumentError, 'Unknown params: asdf')
       @virtual_machine.success.should be_false
     end
 
     it "returns not found for invalid virtual_machines" do
-      expect { @virtual_machine.build(404) }.to raise_error(Squall::NotFound)
+      expect { @virtual_machine.build(404, :template_id => 1) }.to raise_error(Squall::NotFound)
       @virtual_machine.success.should be_false
     end
 
     it "builds the VM" do
-      build = @virtual_machine.build(72)
+      build = @virtual_machine.build(72, :template_id => 1)
 
       @virtual_machine.success.should be_true
-      build['label'].should == 'Testingagain'
     end
   end
 
@@ -226,9 +220,11 @@ describe Squall::VirtualMachine do
       @virtual_machine.success.should be_false
     end
 
-    it "returns error on unknown user" do
-      expect { @virtual_machine.change_owner(1, 404) }.to raise_error(Squall::ServerError)
-      @virtual_machine.success.should be_false
+    pending "this should raise a 422 on OnApp's side, but it's currently raising a 500 which causes HTTParty to explode, see README (and update when fixed)" do
+      it "returns error on unknown user" do
+        expect { @virtual_machine.change_owner(1, 2) }.to raise_error(Squall::ServerError)
+        @virtual_machine.success.should be_false
+      end
     end
 
     it "changes the user" do
@@ -261,6 +257,24 @@ describe Squall::VirtualMachine do
       @virtual_machine.success.should be_true
     end
   end
+  
+  describe "#set_ssh_keys" do
+    use_vcr_cassette "virtual_machine/set_ssh_keys"
+    it "requires an id" do
+      expect { @virtual_machine.set_ssh_keys }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+    
+    it "404s on not found" do
+      expect { @virtual_machine.set_ssh_keys(404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+    
+    it "sets the SSH keys" do
+      result = @virtual_machine.set_ssh_keys(1)
+      @virtual_machine.success.should be_true
+    end
+  end
 
   describe "#migrate" do
     use_vcr_cassette "virtual_machine/migrate"
@@ -275,7 +289,7 @@ describe Squall::VirtualMachine do
     end
 
     it "accepts cold_migrate_on_rollback" do
-      hash = [:post, "/virtual_machines/1/migrate.json", {:query => {:destination => 1, :cold_migrate_on_rollback => 1} }]
+      hash = [:post, "/virtual_machines/1/migrate.json", {:query => {:virtual_machine => {:destination => 1, :cold_migrate_on_rollback => 1}} }]
       @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
       @virtual_machine.migrate 1, :destination => 1, :cold_migrate_on_rollback => 1
     end
@@ -285,18 +299,40 @@ describe Squall::VirtualMachine do
       @virtual_machine.success.should be_false
     end
 
-    it "returns error on unknown destination" do
-      pending "Broken in OnApp" do
-        expect { @virtual_machine.migrate(1, :destination => 404) }.to raise_error(Squall::ServerError)
+    it "404s on unknown destination" do
+        expect { @virtual_machine.migrate(1, :destination => 404) }.to raise_error(Squall::NotFound)
         @virtual_machine.success.should be_false
-      end
     end
 
-    it "changes the destination" do
+    it "changes the hypervisor" do
       pending "Broken in OnApp" do
         result = @virtual_machine.migrate(1, :destination => 2)
         @virtual_machine.success.should be_true
-        result['hypervisor_id'].should == 2
+        result['virtual_machine']['hypervisor_id'].should == 2
+      end
+    end
+  end
+  
+  describe "#set_vip" do
+    use_vcr_cassette "virtual_machine/set_vip"
+    it "requires an id" do
+      expect { @virtual_machine.set_vip }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      expect { @virtual_machine.set_vip(404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "deletes a virtual_machine" do
+      @virtual_machine.set_vip(1)
+      @virtual_machine.success.should be_true
+    end
+    
+    it "sets the vip status to false if currently true" do
+      pending "No way to actually test this without being able to interact with server state" do
+        result = @virtual_machine.set_vip(1)
+        result['virtual_machine']['vip'].should be_false
+        flunk("currently untestable, so make sure it doesn't pass by accident")
       end
     end
   end
@@ -312,7 +348,7 @@ describe Squall::VirtualMachine do
     end
 
     it "deletes a virtual_machine" do
-      virtual_machine = @virtual_machine.delete(2)
+      virtual_machine = @virtual_machine.delete(1)
       @virtual_machine.success.should be_true
     end
   end
@@ -326,24 +362,41 @@ describe Squall::VirtualMachine do
     it "returns not found for invalid virtual_machines" do
       expect { @virtual_machine.resize(404, :memory => 1) }.to raise_error(Squall::NotFound)
     end
-
-    it "requires memory" do
-      @virtual_machine.stub(:request)
-      requires_attr(:memory) { @virtual_machine.resize(1) }
+    
+    it "accepts memory" do
+      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:memory => 1)]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.resize 1, :memory => 1
     end
-
-    it "accepts allow_migration" do
-      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:memory => 1, :allow_migration => 1)]
+    
+    it "accepts cpus" do
+      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:cpus => 1)]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.resize 1, :cpus => 1
+    end
+    
+    it "accepts cpu_shares" do
+      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:cpu_shares => 1)]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.resize 1, :cpu_shares => 1
+    end
+    
+    it "accepts allow_cold_resize" do
+      hash = [:post, "/virtual_machines/1/resize.json",  @virtual_machine.default_params(:allow_cold_resize => 1)]
       @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
-      @virtual_machine.resize 1, :memory => 1, :allow_migration => 1
+      @virtual_machine.resize 1, :allow_cold_resize => 1
     end
 
     it "resizes a virtual_machine" do
-      virtual_machine = @virtual_machine.resize(2, :memory => 1000)
+      virtual_machine = @virtual_machine.resize(1, :memory => 1000)
       @virtual_machine.success.should be_true
 
       virtual_machine['memory'].should == 1000
     end
+    
+    it "requires at least one option" do
+      expect { @virtual_machine.resize(1) }.to raise_error(ArgumentError)
+    end
   end
 
   describe "#suspend" do
@@ -362,22 +415,6 @@ describe Squall::VirtualMachine do
     end
   end
 
-  describe "#unsuspend" do
-    use_vcr_cassette "virtual_machine/unsuspend"
-    it "requires an id" do
-      expect { @virtual_machine.unsuspend }.to raise_error(ArgumentError)
-    end
-
-    it "returns not found for invalid virtual_machines" do
-      expect { @virtual_machine.unsuspend(404) }.to raise_error(Squall::NotFound)
-    end
-
-    it "unsuspends a virtual_machine" do
-      virtual_machine = @virtual_machine.unsuspend(1)
-      virtual_machine['suspended'].should be_false
-    end
-  end
-
   describe "#unlock" do
     use_vcr_cassette "virtual_machine/unlock"
     it "requires an id" do
@@ -427,7 +464,6 @@ describe Squall::VirtualMachine do
     it "will shutdown a virtual_machine" do
       virtual_machine = @virtual_machine.shutdown(1)
       @virtual_machine.success.should be_true
-      virtual_machine['id'].should == 1
     end
   end
 
@@ -446,7 +482,6 @@ describe Squall::VirtualMachine do
     it "will stop a virtual_machine" do
       virtual_machine = @virtual_machine.stop(1)
       @virtual_machine.success.should be_true
-      virtual_machine['id'].should == 1
     end
   end
 
@@ -465,7 +500,84 @@ describe Squall::VirtualMachine do
     it "will reboot a virtual_machine" do
       virtual_machine = @virtual_machine.reboot(1)
       @virtual_machine.success.should be_true
-      virtual_machine['id'].should == 1
+    end
+    
+    it "reboots in recovery" do
+      hash = [:post, "/virtual_machines/1/reboot.json", {:query => {:mode => :recovery}}]
+      @virtual_machine.should_receive(:request).with(*hash).once.and_return({'virtual_machine'=>{}})
+      @virtual_machine.reboot 1, true
+    end
+  end
+  
+  describe "#segregate" do
+    use_vcr_cassette "virtual_machine/segregate"
+    it "requires an id" do
+      expect { @virtual_machine.segregate }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "requires a target_vm_id" do
+      expect { @virtual_machine.segregate 1 }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "404s on not found" do
+      expect { @virtual_machine.segregate(404, 1) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns 404 on unknown target vm id" do
+      expect { @virtual_machine.segregate(1, 404) }.to raise_error(Squall::NotFound)
+      @virtual_machine.success.should be_false
+    end
+
+    it "changes the user" do
+      result = @virtual_machine.segregate(1, 2)
+      @virtual_machine.success.should be_true
+    end
+  end
+  
+  describe "#console" do
+    use_vcr_cassette "virtual_machine/console"
+    it "requires an id" do
+      expect { @virtual_machine.console }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      pending "broken on OnApp (returning 500)" do
+        expect { @virtual_machine.console(404) }.to raise_error(Squall::NotFound)
+        @virtual_machine.success.should be_false
+      end
+    end
+    
+    it "will reboot a virtual_machine" do
+      pending "broken on OnApp (returning 500)" do
+        virtual_machine = @virtual_machine.console(1)
+        @virtual_machine.success.should be_true
+      end
+    end
+  end
+  
+  describe "#stats" do
+    use_vcr_cassette "virtual_machine/stats"
+    it "requires an id" do
+      expect { @virtual_machine.stats }.to raise_error(ArgumentError)
+      @virtual_machine.success.should be_false
+    end
+
+    it "returns not found for invalid virtual_machines" do
+      pending "broken on OnApp (returning 500)" do
+        expect { @virtual_machine.stats(404) }.to raise_error(Squall::NotFound)
+        @virtual_machine.success.should be_false
+      end
+    end
+
+    it "will stop a virtual_machine" do
+      pending "broken on OnApp (returning 500)" do
+        virtual_machine = @virtual_machine.stats(1)
+        @virtual_machine.success.should be_true
+      end
     end
   end
 end

data/spec/squall/whitelist_spec.rb

@@ -0,0 +1,113 @@
+require 'spec_helper'
+
+describe Squall::Whitelist do
+  before(:each) do
+    @whitelist = Squall::Whitelist.new
+    @valid = {:ip => "192.168.1.1"}
+  end
+
+  describe "#list" do
+    use_vcr_cassette "whitelist/list"
+    
+    it "requires user id" do
+      expect { @whitelist.list }.to raise_error(ArgumentError)
+    end
+    
+    it "returns a user's whitelists" do
+      whitelists = @whitelist.list(1)
+      whitelists.should be_an(Array)
+    end
+
+    it "contains the whitelists data" do
+      whitelists = @whitelist.list(1)
+      whitelists.all? {|w| w.is_a?(Hash) }.should be_true
+    end
+  end
+  
+  describe "#show" do
+    use_vcr_cassette "whitelist/show"
+    it "requires an id" do
+      expect { @whitelist.show(1) }.to raise_error(ArgumentError)
+    end
+
+    it "returns not found for invalid whitelists" do
+      expect { @whitelist.show(1, 404) }.to raise_error(Squall::NotFound)
+    end
+
+    it "returns a whitelist" do
+      whitelist = @whitelist.show(1, 2)
+      whitelist.should be_a(Hash)
+    end
+  end
+  
+  describe "#create" do
+    use_vcr_cassette "whitelist/create"
+    it "requires amount" do
+      invalid = @valid.reject{|k,v| k == :ip }
+      requires_attr(:ip) { @whitelist.create(1, invalid) }
+    end
+    
+    it "allows all optional params" do
+      optional = [:description]
+      @whitelist.should_receive(:request).exactly(optional.size).times.and_return Hash.new("whitelist" => {})
+      optional.each do |param|
+        @whitelist.create(1, @valid.merge(param => "test"))
+      end
+    end
+    
+    it "raises error on unknown params" do
+      expect { @whitelist.create(1, @valid.merge(:what => 'what')) }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+    
+    it "raises an error for an invalid user id" do
+      expect { @whitelist.create(404, @valid) }.to raise_error(Squall::NotFound)
+    end
+
+    it "creates a whitelist for a user" do
+      @whitelist.create(1, @valid)
+      @whitelist.success.should be_true
+    end
+  end
+  
+  describe "#edit" do
+    use_vcr_cassette "whitelist/edit"
+    
+    it "allows select params" do
+      optional = [:ip, :description]
+      @whitelist.should_receive(:request).exactly(optional.size).times.and_return Hash.new()
+      optional.each do |param|
+        @whitelist.edit(1, 1, param => "test")
+      end
+    end
+    
+    it "raises error on unknown params" do
+      expect { @whitelist.edit(1, 1, :what => 'what') }.to raise_error(ArgumentError, 'Unknown params: what')
+    end
+
+    it "edits a whitelist" do
+      @whitelist.edit(1, 1, :description => "This is actually a different computer.")
+      @whitelist.success.should be_true
+    end
+    
+    it "raises an error for an invalid whitelist id" do
+      expect { @whitelist.edit(1, 404, @valid) }.to raise_error(Squall::NotFound)
+    end
+  end
+  
+  describe "#delete" do
+    use_vcr_cassette "whitelist/delete"
+    it "requires an id" do
+      expect { @whitelist.delete }.to raise_error(ArgumentError)
+    end
+
+    it "deletes a whitelist" do
+      @whitelist.delete(1, 1)
+      @whitelist.success.should be_true
+    end
+
+    it "returns NotFound for missing user" do
+      expect { @whitelist.delete(1, 404) }.to raise_error(Squall::NotFound)
+    end
+  end
+
+end

data/spec/squall_spec.rb

@@ -14,12 +14,14 @@ describe Squall do
     end
 
     it "returns the config after yield" do
+      Squall.reset_config
       Squall.config { |c| c }.should == {}
       Squall.config.should == {}
     end
 
 
     it "returns the config without a block" do
+      Squall.reset_config
       Squall.config.should == {}
     end
 
@@ -32,7 +34,6 @@ describe Squall do
 
   describe "#reset" do
     it "resets the configuration to defaults" do
-      default_config
       Squall.config.should_not be_empty
       Squall.reset_config
       Squall.config.should be_empty
@@ -41,15 +42,10 @@ describe Squall do
 
   describe "#config_file" do
     it "defaults to ~/.squall" do
-      file = File.join(ENV['HOME'], '.squall.yml')
-      config = {'username' => 'test', 'password' => 'pass', 'base_uri' => 'http://example.com'}
-
+      File.should_receive(:join).with(ENV['HOME'], '.squall.yml').and_return("/path/to/file")
       File.stub(:exists?).and_return(true)
-      YAML.should_receive(:load_file).with(file).and_return(config)
-
-      Squall.configuration_file.should be_nil
+      YAML.stub(:load_file).and_return({})
       Squall.config_file
-      Squall.configuration_file.should == file
     end
 
     it "returns an error if the file doesn't exist" do

data/spec/vcr_cassettes/data_store_zone/create.yml

@@ -0,0 +1,40 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :post
+    uri: http://<USER>:<PASS>@<URL>:80/data_store_zones.json?pack[label]=My%20zone
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic <REDACTED>
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 201
+      message: Created
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      location: 
+      - http://<URL>/data_store_zones/30
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      content-type: 
+      - application/json; charset=utf-8
+      x-runtime: 
+      - "0.044737"
+      server: 
+      - Apache/2.2.3 (CentOS)
+      date: 
+      - Tue, 14 Feb 2012 14:59:58 GMT
+      set-cookie: 
+      - <REDACTED>
+      status: 
+      - "201"
+      cache-control: 
+      - no-cache
+      transfer-encoding: 
+      - chunked
+    body: "{\"data_store_group\":{\"label\":\"My zone\",\"created_at\":\"2012-02-14T14:59:58Z\",\"updated_at\":\"2012-02-14T14:59:58Z\",\"id\":30}}"
+    http_version: "1.1"

data/spec/vcr_cassettes/data_store_zone/delete.yml

@@ -0,0 +1,77 @@
+--- 
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :delete
+    uri: http://<USER>:<PASS>@<URL>:80/data_store_zones/1.json
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic <REDACTED>
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 200
+      message: OK
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      etag: 
+      - "\"99914b932bd37a50b983c5e7c90ae93b\""
+      content-type: 
+      - application/json; charset=utf-8
+      date: 
+      - Tue, 14 Feb 2012 15:05:56 GMT
+      server: 
+      - Apache/2.2.3 (CentOS)
+      x-runtime: 
+      - "0.036527"
+      set-cookie: 
+      - <REDACTED>
+      cache-control: 
+      - max-age=0, private, must-revalidate
+      status: 
+      - "200"
+      transfer-encoding: 
+      - chunked
+    body: "{}"
+    http_version: "1.1"
+- !ruby/struct:VCR::HTTPInteraction 
+  request: !ruby/struct:VCR::Request 
+    method: :delete
+    uri: http://<USER>:<PASS>@<URL>:80/data_store_zones/404.json
+    body: 
+    headers: 
+      content-type: 
+      - application/json
+      authorization: 
+      - Basic <REDACTED>
+  response: !ruby/struct:VCR::Response 
+    status: !ruby/struct:VCR::ResponseStatus 
+      code: 404
+      message: Not Found
+    headers: 
+      x-ua-compatible: 
+      - IE=Edge,chrome=1
+      x-powered-by: 
+      - Phusion Passenger (mod_rails/mod_rack) 3.0.1
+      content-type: 
+      - application/json; charset=utf-8
+      x-runtime: 
+      - "0.037065"
+      server: 
+      - Apache/2.2.3 (CentOS)
+      date: 
+      - Tue, 14 Feb 2012 15:05:56 GMT
+      set-cookie: 
+      - <REDACTED>
+      status: 
+      - "404"
+      cache-control: 
+      - no-cache
+      transfer-encoding: 
+      - chunked
+    body: "{\"errors\":[\"Resource not found\"]}"
+    http_version: "1.1"