praxis 0.16.1 → 0.17.0

data/lib/praxis/types/multipart_array/part_definition.rb

@@ -0,0 +1,52 @@
+module Praxis
+  module Types
+    class MultipartArray < Attributor::Collection
+      class PartDefinition
+
+        attr_accessor :payload_attribute
+        attr_accessor :headers_attribute
+        attr_accessor :filename_attribute
+
+
+        def initialize(&block)
+          self.instance_eval(&block)
+        end
+
+        def update_attribute(attribute, options, block)
+          attribute.options.merge!(options)
+          attribute.type.attributes(options, &block)
+        end
+
+        def create_attribute(type=Attributor::Struct, **opts, &block)
+          # TODO: how do we want to handle any referenced types?
+          return Attributor::Attribute.new(type, opts, &block)
+        end
+
+        def payload(type=Attributor::Struct, **opts, &block)
+          #return @payload if !block_given? && type == Attributor::Struct
+          @payload_attribute = create_attribute(type, **opts, &block)
+        end
+
+        def header(name, val=nil, **options)
+          block = proc { header(name, val, **options) }
+
+          if @headers_attribute
+            update_attribute(@headers_attribute, options, block)
+          else
+            type = Attributor::Hash.of(key: String)
+            @headers_attribute = create_attribute(type,
+                                        dsl_compiler: Praxis::ActionDefinition::HeadersDSLCompiler,
+                                        case_insensitive_load: false, # :(
+                                        allow_extra: true,
+                                        &block)
+          end
+        end
+
+        def filename(type=String, **opts)
+          @filename_attribute = create_attribute(type, **opts)
+        end
+
+      end
+    end
+  end
+end

data/lib/praxis/validation_handler.rb

@@ -0,0 +1,10 @@
+module Praxis
+  class ValidationHandler
+
+    # Should return the Response to send back
+    def handle!(summary:, request:, stage:, errors: nil, exception: nil, **opts)
+      Responses::ValidationError.new(summary: summary, errors: errors, exception: exception, **opts)
+    end
+
+  end
+end

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '0.16.1'
-end
+  VERSION = '0.17.0'
+end

data/praxis.gemspec

@@ -24,9 +24,9 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mustermann', '~> 0'
   spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'mime', '~> 0'
-  spec.add_dependency 'praxis-mapper', '~> 3.4'
-  spec.add_dependency 'praxis-blueprints', '~> 1.3'
-  spec.add_dependency 'attributor', '~> 2.6'
+  spec.add_dependency 'praxis-mapper', '>= 4.0.0'
+  spec.add_dependency 'praxis-blueprints', '>= 2.0.0'
+  spec.add_dependency 'attributor', '>= 4.0.0'
   spec.add_dependency 'thor', '~> 0.18'
   spec.add_dependency 'terminal-table', '~> 1.4'
   spec.add_dependency 'harness', '~> 2'

data/spec/api_browser/directives/type_placeholder_spec.js

@@ -0,0 +1,134 @@
+describe('typePlaceholder', function() {
+  describe('basic operation', function() {
+    var $scope, element, spy, fakeTemplate;
+    beforeEach(angular.mock.module('PraxisDocBrowser', function($provide) {
+      spy = jasmine.createSpy('templateFor').and.callFake(function() {
+        return fakeTemplate();
+      });
+      $provide.value('templateFor', spy);
+    }));
+
+    beforeEach(inject(function($compile, $rootScope, $q) {
+      fakeTemplate = function() {
+        return $q.when($compile('<div>result = <span>{{type.name}}</div>'));
+      };
+      $scope = $rootScope.$new();
+      $scope.type = {name: 'test'};
+      element = $compile('<div><type-placeholder type=type template=embedded></type-placeholder></div>')($scope);
+      $scope.$apply();
+    }));
+
+    it('calls template for', function() {
+      expect(spy).toHaveBeenCalledWith($scope.type, 'embedded');
+    });
+
+    it('replaces itself', function() {
+      expect(element.text()).toEqual('result = test');
+    });
+  });
+
+  describe('actual rendering', function() {
+    var $scope, element;
+
+    function rowLooksLike(n, vals) {
+      return function() {
+        var row = element.find('table tr').eq(n).children();
+        _.each(vals, function(val, i) {
+          if (_.isString(val)) {
+            expect(row.eq(i).text()).toEqual(val);
+          } else {
+            expect(row.eq(i).text()).toMatch(val);
+          }
+        });
+        expect(row.length).toBe(vals.length);
+      };
+    }
+
+    beforeEach(angular.mock.module('PraxisDocBrowser'));
+
+    describe('standalone', function() {
+      beforeEach(inject(function($compile, $rootScope) {
+        $scope = $rootScope.$new();
+        $scope.type = { // TODO figure out how to exercise the entire app
+          name: 'Struct',
+          family: 'hash',
+          attributes: {
+            view: {
+              options: {
+                default: 'default',
+                example: '"default"'
+              },
+              type: {
+                name: 'String'
+              }
+            }
+          }
+        };
+        element = $compile('<div><type-placeholder type="type" template="standalone" details="type.attributes"></type-placeholder></div>')($scope);
+        $scope.$apply();
+      }));
+
+      it('renders out a table', function() {
+        expect(element.find('table').length).toBe(1);
+      });
+
+      it('displays table headings', rowLooksLike(0,
+        ['Attribute', 'Type', 'Description']
+      ));
+
+      it('displays an optional heading', rowLooksLike(1,
+        ['Optional']
+      ));
+
+      it('has a table row for the attribute', rowLooksLike(2,
+        ['view', 'String', /default.*default.*example.*"default"/mi]
+      ));
+    });
+
+    describe('embedded', function() {
+      var compile;
+      beforeEach(inject(function($compile, $rootScope) {
+        $scope = $rootScope.$new();
+        compile = $compile('<div><table><tr type-placeholder type="item.type" template="embedded" details="item" name="item.name"></tr></table></div>');
+      }));
+
+      describe('struct', function() {
+        beforeEach(function() {
+          $scope.item = { // TODO figure out how to exercise the entire app
+            type: {
+              name: 'Struct',
+              family: 'hash',
+              attributes: {
+                view: {
+                  options: {
+                    default: 'default',
+                    example: '"default"'
+                  },
+                  type: {
+                    name: 'String'
+                  }
+                }
+              }
+            },
+            name: 'Test1',
+            description: 'Heading'
+          };
+          element = compile($scope);
+          $scope.$apply();
+        });
+
+        it('renders out a table', function() {
+          expect(element.find('table').length).toBe(1);
+        });
+
+        it('displays a row fow the type', rowLooksLike(0,
+          ['Test1', 'Struct', /Heading/]
+        ));
+
+        it('displays a row for the subattribute', rowLooksLike(1,
+          ['Test1.view', 'String', /default.*default.*example.*"default"/mi]
+        ));
+      });
+    });
+  });
+});

data/spec/api_browser/factories/normalize_attributes_spec.js

@@ -0,0 +1,97 @@
+describe('normalizeAttributes', function() {
+  var normalizeAttributes;
+  beforeEach(angular.mock.module('PraxisDocBrowser'));
+
+  beforeEach(inject(function($rootScope, $injector) {
+    normalizeAttributes = $injector.get('normalizeAttributes');
+  }));
+
+  var type = {
+    attributes: {
+      test1: {
+        values: ['Hello'],
+        irrelevantFlag: true
+      },
+      test2: {
+        type: {
+          attributes: {
+            test3: {
+              default: 'Yeah'
+            },
+            moreRecursive: {
+              type: {
+                attributes: {
+                  test4: {}
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    example: {
+      test1: 'Hello',
+      test2: {
+        test3: 'Yeah',
+        moreRecursive: {
+          test4: 3
+        }
+      }
+    }
+  };
+
+  var expected = {
+    test1: {
+      options: {
+        values: ['Hello'],
+        example: '"Hello"'
+      }
+    },
+    test2: {
+      options: {
+        example: '{\n  "test3": "Yeah",\n  "moreRecursive": {\n    "test4": 3\n  }\n}'
+      },
+      type: {
+        attributes: {
+          test3: {
+            options: {
+              default: 'Yeah',
+              example: '"Yeah"'
+            }
+          },
+          moreRecursive: {
+            options: {
+              example: '{\n  "test4": 3\n}'
+            },
+            type: {
+              attributes: {
+                test4: {
+                  options: {
+                    example: '3'
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  };
+
+  expected = (function wrap(obj) { // this will wrap each object in objectContaining
+    if (_.isObject(obj)) {
+      return jasmine.objectContaining(_.mapValues(obj, wrap));
+    }
+    return obj;
+  })(expected);
+
+
+  it('normalizes attributes into options recursively', function() {
+    normalizeAttributes(type, type.attributes);
+    expect(type.attributes).toEqual(expected);
+  });
+
+  it('doesn\'t include irrelevant options', function() {
+    expect(type.attributes.test1.options.irrelevantFlag).toBeUndefined();
+  });
+});

data/spec/api_browser/factories/template_for_spec.js

@@ -0,0 +1,67 @@
+describe('templateFor service', function() {
+  var $scope, templateFor, $http, customResolver;
+
+  beforeEach(angular.mock.module('PraxisDocBrowser'));
+
+  beforeEach(function() {
+    customResolver = function() {};
+    angular.module('PraxisDocBrowser').config(function(templateForProvider) {
+      templateForProvider.register(function($type, $family) {
+        return customResolver($type, $family);
+      });
+    });
+  });
+
+  beforeEach(inject(function($rootScope, $injector) {
+    $scope = $rootScope.$new();
+    $http = $injector.get('$http');
+    templateFor = $injector.get('templateFor');
+  }));
+
+  describe('default templates', function() {
+    beforeEach(inject(function($templateCache) {
+      $templateCache.put('views/types/standalone/struct.html', '<div>standalone -> Struct</div>');
+      $templateCache.put('views/types/standalone/default.html', '<div>standalone -> Default</div>');
+      $templateCache.put('views/types/embedded/links.html', '<div>embedded -> Links</div>');
+      $templateCache.put('views/types/embedded/struct.html', '<div>embedded -> Struct</div>');
+      $templateCache.put('views/types/embedded/default.html', '<div>embedded -> Default</div>');
+    }));
+    _.each(['standalone', 'embedded'], function(templateType) {
+      _.each([
+        {name: 'Struct', family: 'hash'},
+        {name: 'Links', family: 'hash'},
+        {name: 'Default', family: 'Numeric'}
+      ], function(type) {
+        it('resolve ' + templateType + ' ' + type.name, function() {
+          var result;
+          templateFor(type, templateType).then(function(template) {
+            result = template($scope);
+          });
+          $scope.$apply();
+          var name = templateType === 'standalone' && type.name === 'Links' ? 'Struct' : type.name;
+          expect(result.text().split(' -> ')).toEqual([templateType, name]);
+        });
+      });
+    });
+  });
+
+  describe('custom templates', function() {
+    var result;
+    beforeEach(inject(function($templateCache) {
+      $templateCache.put('views/mytype.html', '<div>custom</div>');
+      customResolver = jasmine.createSpy().and.returnValue('views/mytype.html');
+      templateFor({name: 'Custom', family: 'CustomFamily'}, true).then(function(template) {
+        result = template($scope);
+      });
+      $scope.$apply();
+    }));
+
+    it('calls the custom resolver', function() {
+      expect(customResolver).toHaveBeenCalledWith('Custom', 'CustomFamily');
+    });
+
+    it('returns the custom template', function() {
+      expect(result.text()).toEqual('custom');
+    });
+  });
+});

data/spec/functional_spec.rb

@@ -12,12 +12,70 @@ describe 'Functional specs' do
 
     context 'with a valid request' do
       it 'is successful' do
-        get '/clouds/1/instances?api_version=1.0', nil, 'global_session' => session
+        get '/api/clouds/1/instances?api_version=1.0', nil, 'global_session' => session
         expect(last_response.headers['Content-Type']).to(
         eq("application/vnd.acme.instance;type=collection"))
       end
     end
 
+    context 'with a path param that can not load' do
+      it 'returns a useful error' do
+        get '/api/clouds/invalid/instances?api_version=1.0', nil, 'global_session' => session
+
+        expect(last_response.status).to eq 400
+
+        response = JSON.parse(last_response.body)
+        expect(response['name']).to eq 'ValidationError'
+        expect(response['summary']).to eq 'Error loading params.'
+        expect(response['errors']).to match_array([/Error loading attribute \$\.params\.cloud_id/])
+        expect(response['cause']['name']).to eq 'ArgumentError'
+      end
+    end
+
+    context 'with a header that can not load' do
+      it 'returns a useful error' do
+        get '/api/clouds/1/instances?api_version=1.0', nil, 'global_session' => session, 'HTTP_ACCOUNT_ID' => 'invalid'
+
+        expect(last_response.status).to eq 400
+
+        response = JSON.parse(last_response.body)
+
+        expect(response['name']).to eq 'ValidationError'
+        expect(response['summary']).to eq 'Error loading headers.'
+        expect(response['errors']).to match_array([/Error loading attribute .*Account-Id"/])
+        expect(response['cause']['name']).to eq 'ArgumentError'
+      end
+    end
+
+    context 'with a param that is invalid' do
+      it 'returns a useful error' do
+        get '/api/clouds/-1/instances?api_version=1.0', nil, 'global_session' => session
+
+        expect(last_response.status).to eq 400
+
+        response = JSON.parse(last_response.body)
+
+        expect(response['name']).to eq 'ValidationError'
+        expect(response['summary']).to eq 'Error validating request data.'
+        expect(response['errors']).to match_array([/.*cloud_id.*is smaller than the allowed min/])
+      end
+
+    end
+
+    context 'with a header that is invalid' do
+      it 'returns a useful error' do
+        get '/api/clouds/1/instances?api_version=1.0', nil, 'global_session' => session, 'HTTP_ACCOUNT_ID' => '-1'
+
+        expect(last_response.status).to eq 400
+
+        response = JSON.parse(last_response.body)
+
+        expect(response['name']).to eq 'ValidationError'
+        expect(response['summary']).to eq 'Error validating request data.'
+        expect(response['errors']).to match_array([/.*headers.*Account-Id.*is smaller than the allowed min/])
+      end
+    end
+
     context 'with an incorrect response_content_type param' do
       around do |example|
         logger = app.logger
@@ -29,13 +87,13 @@ describe 'Functional specs' do
       end
 
       it 'fails to validate the response' do
-        get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0', nil, 'HTTP_FOO' => "bar", 'global_session' => session
+        get '/api/clouds/1/instances?response_content_type=somejunk&api_version=1.0', nil, 'HTTP_FOO' => "bar", 'global_session' => session
         expect(last_response.status).to eq(400)
         response = JSON.parse(last_response.body)
 
         expect(response['name']).to eq('ValidationError')
-
-        expect(response["message"]).to match(/Bad Content-Type/)
+        expect(response['summary']).to eq("Error validating response")
+        expect(response['errors'].first).to match(/Bad Content-Type/)
       end
 
       context 'with response validation disabled' do
@@ -48,7 +106,7 @@ describe 'Functional specs' do
 
         it 'fails to validate the response' do
           expect {
-            get '/clouds/1/instances?response_content_type=somejunk&api_version=1.0',nil,  'global_session' => session
+            get '/api/clouds/1/instances?response_content_type=somejunk&api_version=1.0',nil,  'global_session' => session
           }.to_not raise_error
         end
 
@@ -59,7 +117,7 @@ describe 'Functional specs' do
 
   it 'works' do
     the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
-    get '/clouds/1/instances/2?junk=foo&api_version=1.0', nil,'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
+    get '/api/clouds/1/instances/2?junk=foo&api_version=1.0', nil,'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
     expect(last_response.status).to eq(200)
     expected = {
       "cloud_id" => 1,
@@ -76,20 +134,20 @@ describe 'Functional specs' do
     expect(JSON.parse(last_response.body)).to eq(expected)
 
     headers = last_response.headers
-    expect(headers['Content-Type']).to eq('application/vnd.acme.instance')
+    expect(headers['Content-Type']).to eq('application/json')
     expect(headers['Spec-Middleware']).to eq('used')
     expect(headers['Content-Length']).to eq(last_response.body.size.to_s)
   end
 
   it 'returns early when making the before filter break' do
-    get '/clouds/1/instances/2?junk=foo&api_version=1.0&fail_filter=true', nil, 'global_session' => session
+    get '/api/clouds/1/instances/2?junk=foo&api_version=1.0&fail_filter=true', nil, 'global_session' => session
     expect(last_response.status).to eq(401)
   end
 
   context 'bulk_create multipart' do
 
     let(:instance) { Instance.example }
-    let(:instance_json) { JSON.pretty_generate(instance.render(:create)) }
+    let(:instance_json) { JSON.pretty_generate(instance.render(view: :create)) }
 
     let(:form) do
       form_data = MIME::Multipart::FormData.new
@@ -102,13 +160,13 @@ describe 'Functional specs' do
     let(:body) { form.body.to_s }
 
     it 'works' do
-
-      post '/clouds/1/instances?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+      post '/api/clouds/1/instances?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
 
       _reponse_preamble, response = Praxis::MultipartParser.parse(last_response.headers, last_response.body)
       expect(response).to have(1).item
 
-      response_id, instance_part = response.first
+      instance_part = response.first
+      response_id = instance_part.name
       expect(response_id).to eq(instance.id.to_s)
 
       instance_headers = instance_part.headers
@@ -117,7 +175,7 @@ describe 'Functional specs' do
 
       response_instance = JSON.parse(instance_part.body)
       expect(response_instance["key"]).to eq(instance.id)
-      expect(response_instance["value"].values).to eq(instance.render(:create).values)
+      expect(response_instance["value"].values).to eq(instance.render(view: :create).values)
     end
   end
 
@@ -140,7 +198,7 @@ describe 'Functional specs' do
 
     context 'with a valid payload' do
       before do
-        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+        post '/api/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
       end
 
       subject(:response) { JSON.parse(last_response.body) }
@@ -153,7 +211,7 @@ describe 'Functional specs' do
         its(['filename']) { should eq('docker') }
         its(['type']) { should eq('text/plain') }
         its(['name']) { should eq('file') }
-        its(['tempfile']) { should match(/^\//) }
+        its(['tempfile']) { should eq('DOCKER_HOST=tcp://127.0.0.1:2375') }
       end
     end
 
@@ -170,7 +228,7 @@ describe 'Functional specs' do
       let(:body) { form.body.to_s }
 
       it 'returns an error' do
-        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+        post '/api/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
         response = JSON.parse(last_response.body)
 
         expect(response['name']).to eq('ValidationError')
@@ -200,22 +258,19 @@ describe 'Functional specs' do
       subject(:response) { JSON.parse(last_response.body) }
 
       before do
-        post '/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+        post '/api/clouds/1/instances/2/files?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
       end
       its(:keys){ should eq(['destination_path','file','options'])}
       its(['options']){ should eq({"extra_thing"=>"I am extra"})}
     end
 
-
-
-
   end
 
 
   context 'not found and API versions' do
     context 'when no version is speficied' do
       it 'it tells you which available api versions would match' do
-        get '/clouds/1/instances/2?junk=foo',nil, 'global_session' => session
+        get '/api/clouds/1/instances/2?junk=foo',nil, 'global_session' => session
 
         expect(last_response.status).to eq(404)
         expect(last_response.headers["Content-Type"]).to eq("text/plain")
@@ -232,7 +287,7 @@ describe 'Functional specs' do
 
     context 'when some version is speficied, but wrong' do
       it 'it tells you which possible correcte api versions exist' do
-        get '/clouds/1/instances/2?junk=foo&api_version=50.0', nil, 'global_session' => session
+        get '/api/clouds/1/instances/2?junk=foo&api_version=50.0', nil, 'global_session' => session
 
         expect(last_response.status).to eq(404)
         expect(last_response.headers["Content-Type"]).to eq("text/plain")
@@ -243,26 +298,26 @@ describe 'Functional specs' do
   end
 
   context 'volumes' do
+    before do
+      header 'X-Api-Version', '1.0'
+    end
+
     context 'when no authorization header is passed' do
       it 'works as expected' do
-        get '/v1.0/volumes/123?junk=stuff', nil, 'global_session' => session
+        get '/api/clouds/1/volumes/123?junk=stuff', nil, 'global_session' => session
         expect(last_response.status).to eq(200)
-        expect(JSON.parse(last_response.body)).to eq({"id"=>123,
-                                                      "other_params"=>{
-                                                        "junk"=>"stuff",
-                                                      "some_date"=>"2012-12-21T00:00:00+00:00"}
-                                                      })
+        expect(Volume.load(last_response.body).validate).to be_empty
         expect(last_response.headers["Content-Type"]).to eq("application/vnd.acme.volume")
       end
     end
     context 'when an authorization header is passed' do
       it 'returns 401 when it does not match "secret" ' do
-        get '/v1.0/volumes/123?junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'foobar', 'global_session' => session
+        get '/api/clouds/1/volumes/123?junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'foobar', 'global_session' => session
         expect(last_response.status).to eq(401)
         expect(last_response.body).to match(/Authentication info is invalid/)
       end
       it 'succeeds as expected when it matches "secret" ' do
-        get '/v1.0/volumes/123?junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'the secret', 'global_session' => session
+        get '/api/clouds/1/volumes/123?junk=stuff', nil, 'HTTP_AUTHORIZATION' => 'the secret', 'global_session' => session
         expect(last_response.status).to eq(200)
       end
 
@@ -270,7 +325,7 @@ describe 'Functional specs' do
 
     context 'index action with no args defined' do
       it 'dispatches successfully' do
-        get '/v1.0/volumes', nil, 'HTTP_AUTHORIZATION' => 'the secret', 'global_session' => session
+        get '/api/clouds/1/volumes', nil, 'HTTP_AUTHORIZATION' => 'the secret', 'global_session' => session
         expect(last_response.status).to eq(200)
       end
     end
@@ -278,11 +333,11 @@ describe 'Functional specs' do
 
   context 'wildcard verb routing' do
     it 'can terminate instances with POST' do
-      post '/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
     it 'can terminate instances with DELETE' do
-      post '/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
 
@@ -290,11 +345,11 @@ describe 'Functional specs' do
 
   context 'route options' do
     it 'reach the endpoint that does not match the except clause' do
-      get '/clouds/23/otherinstances/_action/test?api_version=1.0', nil, 'global_session' => session
+      get '/api/clouds/23/otherinstances/_action/test?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
     it 'does NOT reach the endpoint that matches the except clause' do
-      get '/clouds/23/otherinstances/_action/exceptional?api_version=1.0', nil, 'global_session' => session
+      get '/api/clouds/23/otherinstances/_action/exceptional?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(404)
     end
 
@@ -303,12 +358,12 @@ describe 'Functional specs' do
 
   context 'auth_plugin' do
     it 'can terminate' do
-      post '/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
+      post '/api/clouds/23/instances/1/terminate?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(200)
     end
 
     it 'can not stop' do
-      post '/clouds/23/instances/1/stop?api_version=1.0', nil, 'global_session' => session
+      post '/api/clouds/23/instances/1/stop?api_version=1.0', nil, 'global_session' => session
       expect(last_response.status).to eq(403)
     end
   end
@@ -318,24 +373,24 @@ describe 'Functional specs' do
     let(:content_type) { 'application/x-www-form-urlencoded' }
 
     before do
-      post '/clouds/1/instances/2/terminate?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+      post '/api/clouds/1/instances/2/terminate?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
     end
 
     it 'returns a useful error message' do
       body = JSON.parse(last_response.body)
       expect(body['name']).to eq('ValidationError')
-      expect(body['message']).to match("For request Content-Type: 'application/x-www-form-urlencoded'")
+      expect(body['summary']).to match("Error loading payload. Used Content-Type: 'application/x-www-form-urlencoded'")
+      expect(body['errors']).to_not be_empty
     end
   end
 
   context 'update' do
 
-
     let(:body) { JSON.pretty_generate(request_payload) }
     let(:content_type) { 'application/json' }
 
     before do
-      patch '/clouds/1/instances/3?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
+      patch '/api/clouds/1/instances/3?api_version=1.0', body, 'CONTENT_TYPE' => content_type, 'global_session' => session
     end
 
     subject(:response_body) { JSON.parse(last_response.body) }
@@ -348,17 +403,28 @@ describe 'Functional specs' do
     end
 
     context 'with a provided name' do
-      let(:request_payload) { {name: 'My Instance'} }
-      its(['name']) { should eq('My Instance') }
+      let(:request_payload) { {name: 'MyInstance'} }
+      its(['name']) { should eq('MyInstance') }
       it { should_not have_key('root_volume') }
     end
 
     context 'with an explicitly-nil root_volme' do
-      let(:request_payload) { {name: 'My Instance', root_volume: nil} }
-      its(['name']) { should eq('My Instance') }
+      let(:request_payload) { {name: 'MyInstance', root_volume: nil} }
+      its(['name']) { should eq('MyInstance') }
       its(['root_volume']) { should be(nil) }
     end
 
+    context 'with an invalid name' do
+      let(:request_payload) { {name: 'Invalid Name'} }
+
+      its(['name']) { should eq 'ValidationError' }
+      its(['summary']) { should eq 'Error validating response' }
+      its(['errors']) { should match_array [/\$\.name value \(Invalid Name\) does not match regexp/] }
+
+      it 'returns a validation error' do
+        expect(last_response.status).to eq(400)
+      end
+    end
 
   end