closes #101

Author: catmando

ruby/hyper-operation/lib/hyper-operation/exception.rb

@@ -1,6 +1,15 @@
+module Mutations
+  class ErrorArray
+    def self.new_from_error_hash(errors)
+      new(errors.collect do |key, values|
+        ErrorAtom.new(key, values[:symbol], values)
+      end)
+    end
+  end
+end
+
 module Hyperstack
   class AccessViolation < StandardError
-
     attr_accessor :details
 
     def initialize(message = nil, details = nil)
@@ -15,7 +24,16 @@ def __hyperstack_on_error(operation, params, fmted_message)
 
   class Operation
     class ValidationException < Mutations::ValidationException
+      def as_json(*)
+        errors.as_json
+      end
+
+      def initialize(errors)
+        unless errors.is_a? Mutations::ErrorHash
+          errors = Mutations::ErrorArray.new_from_error_hash(errors)
+        end
+        super(errors)
+      end
     end
   end
-
 end

ruby/hyper-operation/lib/hyper-operation/server_op.rb

@@ -20,7 +20,11 @@ def run(*args)
               deserialize_response response.json[:response]
             end
             .fail do |response|
-              Exception.new response.json[:error]
+              begin
+                const_get(response.json[:error_class]).new(response.json[:error])
+              rescue
+                Exception.new response.json[:error]
+              end
             end
           end
         elsif on_opal_server?
@@ -84,6 +88,16 @@ def run_from_client(security_param, controller, operation, params)
         handle_exception(e, operation, params)
       end
 
+      def status(e)
+        if e.is_a? AccessViolation
+          403
+        elsif e.is_a? Operation::ValidationException
+          400
+        else
+          500
+        end
+      end
+
       def handle_exception(e, operation, params)
         if e.respond_to? :__hyperstack_on_error
           params = params.to_h
@@ -93,7 +107,8 @@ def handle_exception(e, operation, params)
           message << "\n#{e.details}" if e.respond_to? :details
           e.__hyperstack_on_error(operation, params, message.join("\n"))
         end
-        { json: { error: e }, status: 500 }
+
+        { json: { error_class: e.class.to_s, error: e}, status: status(e) }
       end
 
 

ruby/hyper-operation/spec/hyper-operation/server_op_spec.rb

@@ -2,7 +2,14 @@
 
 describe "isomorphic operations", js: true do
 
+  let(:response_spy) { spy('response_spy') }
+
   before(:each) do
+
+    allow(Hyperstack::ServerOp).to receive(:run_from_client).and_wrap_original do |m, *args|
+      m.call(*args).tap { |r| response_spy.status = r[:status] }
+    end
+
     on_client do
       class Test
         include Hyperstack::Component
@@ -65,28 +72,65 @@ def fact(x)
 
     it "will pass server failures back" do
       ServerFacts.param :acting_user, nils: true
+
       expect_promise do
-        ServerFacts.run(n: -1).fail { |exception| Promise.new.resolve(exception) }
-      end.to eq('N is too small')
+        ServerFacts.run(n: -1).fail { |exception| Promise.new.resolve(exception.inspect) }
+      end.to eq('#<Hyperstack::Operation::ValidationException: n is too small>')
+      expect(response_spy).to have_received(:status=).with(400)
       expect_promise do
-        ServerFacts.run(n: 10000000000).fail { |exception| Promise.new.resolve(exception) }
-      end.to eq('stack level too deep')
+        ServerFacts.run(n: 10000000000).fail { |exception| Promise.new.resolve(exception.inspect) }
+      end.to eq('#<Exception: stack level too deep>')
+      expect(response_spy).to have_received(:status=).with(500)
+    end
+
+    it "pass abort status back" do
+      # just to check we will actually interrogate the structure of the exception in this spec
+      ServerFacts.param :acting_user, nils: true
+      class ServerFacts < Hyperstack::ServerOp
+        step { abort! }
+      end
+      expect_promise do
+        ServerFacts.run(n: 5).fail do |exception|
+          Promise.new.resolve(exception.inspect)
+        end
+      end.to eq('#<Hyperstack::Operation::Exit: Hyperstack::Operation::Exit>')
+      expect(response_spy).to have_received(:status=).with(500)
+    end
+
+    it "pass failure data back" do
+      # just to check we will actually interrogate the structure of the exception in this spec
+      ServerFacts.param :acting_user, nils: true
+      class ServerFacts < Hyperstack::ServerOp
+        step { raise 'failure' }
+        failed { [{'some' => 'data'}] }
+      end
+      expect_promise do
+        ServerFacts.run(n: 5).fail do |exception|
+          Promise.new.resolve(exception)
+        end
+      end.to eq([{'some' => 'data'}])
+      expect(response_spy).to have_received(:status=).with(500)
     end
 
     it "pass validation failures back" do
+      # just to check we will actually interrogate the structure of the exception in this spec
       ServerFacts.param :acting_user, nils: true
       class ServerFacts < Hyperstack::ServerOp
         validate { false }
       end
       expect_promise do
-        ServerFacts.run(n: 5).fail { |exception| Promise.new.resolve(exception) }
-      end.to include('param validation 1 failed')
+        ServerFacts.run(n: 5).fail do |exception|
+          Promise.new.resolve(exception.errors.message_list)
+        end
+      end.to eq(['param validation 1 failed'])
+      expect(response_spy).to have_received(:status=).with(400)
     end
 
     it "will reject uplinks that don't accept acting_user" do
       expect_promise do
         ServerFacts.run(n: 5).fail { |exception| Promise.new.resolve(exception) }
       end.to include('Hyperstack::AccessViolation')
+      expect(response_spy).to have_received(:status=).with(403)
     end
   end