closes #396

catmando · catmando · commit fcc8e358a024 · 2021-03-31T14:33:48.000-04:00
diff --git a/docs/development-workflow/hyper-spec/01-installation.md b/docs/development-workflow/hyper-spec/01-installation.md
@@ -11,15 +11,6 @@ end
 
 Make sure to `bundle install`.
 
-> Note: if you want to use the unreleased edge branch your hyper-spec gem specification will be:
->
-> ```ruby
-> gem 'hyper-spec',
->      git: 'git://github.com/hyperstack-org/hyperstack.git',
->      branch: 'edge',
->      glob: 'ruby/*/*.gemspec'
-> ```
-
 HyperSpec is integrated with the `pry` gem for debugging, so it is recommended to add the `pry` gem as well.
 
 HyperSpec will also use the `timecop` gem if present to allow you to control and synchronize time on the server and the client.
diff --git a/docs/development-workflow/hyper-spec/03-methods-and-features.md b/docs/development-workflow/hyper-spec/03-methods-and-features.md
@@ -75,6 +75,9 @@ See the [Client Initialization Options](#client-initialization-options) section
 
 By default the client environment will be reinitialized at the beginning of every spec.  If this is not needed you can speed things up by adding the `no_reset` flag to a block of specs.
 
+> Note if you are using `visit` to directly load a page and still want to use methods like `on_client` and the expectation helpers, see the last section on
+using visit at the end of this document.
+
 # Details
 
 ### The `on_client` method
@@ -438,3 +441,11 @@ You can also run specs in a visible chrome window by setting the `DRIVER` enviro
 The method is typically not needed assuming you are using a multithreaded server like Puma.  If for whatever reason the pry debug session is not multithreaded, *and* you want to try some kind of experiment on the javascript console, *and* those experiments make requests to the server, you may not get a response, because all threads are in use.  
 
 You can resolve this by using the `pause` method in the debug session which will put the server debug session into a non-blocking loop.  You can then experiment in the JS console, and when done release the pause by executing `go()` in the *javascript* debug console.
+
+### Using `visit` and the Application Layout
+Currently this is not well integrated (see [issue 398](https://github.com/hyperstack-org/hyperstack/issues/398)).  If you want to visit a page on the website
+using `visit`, the following will not work: Timecop integration, and the `insert_html` and `before_mount` methods.  You will also have to execute this line in your spec:
+```ruby
+page.instance_variable_set("@hyper_spec_mounted", true)
+```
+Upvote issue 398 if this presents a big problem for you.
diff --git a/release-notes/1.0.alpha1.6.md b/release-notes/1.0.alpha1.6.md
@@ -1,5 +1,13 @@
 ## 1.0alpha1.6 - 2021-03-29
 
+| Release<br/>Date | Version | Open<br/>Issues | Documentation<br/>Sections<br/>Draft Ready | Documentation<br/>Sections<br/>WIP |
+|--------------|---------|-------------|-------|------|
+| March 29, 2021 | 1.0.alpha1.6 | 167 | 35 | 10 |
+
+> Open issues includes enhancements, documentation, and discussion issues as well as few bugs.
+>
+> The documentation WIP (work in progress) numbers are approx, as more sections may be added.
+
 ### New Major Features
 + Now compatible with Opal 1.x and Rails 6.x:  Tested with Opal ~>1.0 + Rails ~>5.0 and Rails ~>6.0, and Opal ~>0.11 and Rails ~>5.0.
 + You can run Hypermodel connections on Redis (instead of ActiveRecord).  This gives about a 10% performance boost, and there will be even better
diff --git a/ruby/hyper-operation/lib/hyper-operation/promise.rb b/ruby/hyper-operation/lib/hyper-operation/promise.rb
@@ -123,6 +123,7 @@ def resolve(value = nil)
 
     begin
       if block = @action[:success] || @action[:always]
+        @realized = :resolve
         value = block.call(value)
       end
 
@@ -156,6 +157,9 @@ def reject(value = nil)
 
     begin
       if block = @action[:failure] || @action[:always]
+        # temporarily set values so always can determine if this
+        # was a reject or resolve
+        @realized = :reject
         value = block.call(value)
       end
 
diff --git a/ruby/hyper-operation/lib/hyper-operation/railway/run.rb b/ruby/hyper-operation/lib/hyper-operation/railway/run.rb
@@ -64,7 +64,10 @@ def step(opts)
 
       def failed(opts)
         @promise_chain = @promise_chain
-          .always { |result| apply(result, :failed, opts) }
+          .always do |result|
+            @state = :failed if @promise_chain.rejected? && @state != :abort
+            apply(result, :failed, opts)
+          end
       end
 
       def async(opts)
diff --git a/ruby/hyper-operation/spec/hyper-operation/execution_spec.rb b/ruby/hyper-operation/spec/hyper-operation/execution_spec.rb
@@ -28,6 +28,42 @@ def self.promise
     expect(MyOperation.run(i: 1).tap { MyOperation.promise.resolve(2) }.value).to eq 4
   end
 
+  it "will chain rejected promises" do
+    MyOperation.class_eval do
+      def self.promise
+        @promise ||= Promise.new
+      end
+      param :i
+      step { self.class.promise }
+      step { @took_a_bad_step = true }
+      failed { |e| e unless @took_a_bad_step }
+    end
+    expect(
+      MyOperation.run(i: 1)
+        .always { |failure| failure }
+        .tap { MyOperation.promise.reject("promise rejected") }
+        .value
+    ).to eq "promise rejected"
+  end
+
+  it "will chain promises that raise exceptions" do
+    MyOperation.class_eval do
+      def self.promise
+        @promise ||= Promise.new.then { raise "exception raised" }.tap { |p| p.resolve }
+      end
+      param :i
+      step { self.class.promise }
+      step { @took_a_bad_step = true }
+      failed { |e| e unless @took_a_bad_step }
+    end
+    expect(
+      MyOperation.run(i: 1)
+        .always { |failure| failure.message }
+        .tap { } #MyOperation.promise.resolve }
+        .value
+    ).to eq "exception raised"
+  end
+
   it "will interrupt the promise chain with async" do
     MyOperation.class_eval do
       def self.promise
@@ -217,7 +253,8 @@ def say_instance_hello()
   before(:step) do
     on_client do
       def get_round_tuit(value)
-        Promise.new.tap { |p| after(0.1) { p.resolve(value) } }
+        Promise.new.tap { |p| after(0.2) { value == :reject ? p.reject("promise rejected") : p.resolve(value) } }
+               .then { |v| value == :exception ? raise("exception raised") : v }
       end
       module DontCallMe
         def called?
@@ -260,6 +297,40 @@ def say_hello
     end.to eq 4
   end
 
+  it "will chain rejected promises" do
+    expect do
+      Class.new(Hyperstack::Operation) do
+        param :i
+        step { get_round_tuit(:reject) }
+        step { @took_a_bad_step = true }
+        failed { |e| e unless @took_a_bad_step }
+      end.run(i: 1).always { |failure| failure }
+    end.on_client_to eq "promise rejected"
+  end
+
+  it "will chain promises that raise exceptions" do
+    expect do
+      Class.new(Hyperstack::Operation) do
+        param :i
+        step { get_round_tuit(:exception) }
+        step { @took_a_bad_step = true }
+        failed { |e| e unless @took_a_bad_step }
+      end.run(i: 1).always { |failure| failure }
+    end.on_client_to eq "exception raised"
+  end
+
+  it "will interrupt the promise chain with async" do
+    expect_promise do
+      Class.new(Hyperstack::Operation) do
+        param :i
+        step { get_round_tuit(2) }
+        step { |n| params.i + n }
+        step { |r| r + params.i }
+        async { 'hi' }
+      end.run(i: 1)
+    end.to eq 'hi'
+  end
+
   it "will interrupt the promise chain with async" do
     expect_promise do
       Class.new(Hyperstack::Operation) do
