commute 0.2.0.rc.2 → 0.3.0.pre

data/spec/commute/core/http_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+require 'commute/core/http'
+
+describe Commute::Http::Status do
+
+  Status = Commute::Http::Status
+
+  it 'should be a failure for 4xx and 5xx status codes' do
+    Status.new(420).fail?.must_equal true
+    Status.new(501).fail?.must_equal true
+    Status.new(501).success?.must_equal false
+  end
+
+  it 'should be a success otherwise' do
+    Status.new(200).success?.must_equal true
+    Status.new(200).fail?.must_equal false
+    Status.new(301).success?.must_equal true
+  end
+end
+
+describe Commute::Http::Request do
+
+  it 'should have some default values' do
+    request = Commute::Http::Request.new nil
+    request.uri.path.must_equal '/'
+    request.headers.must_be_empty
+    request.query.must_be_empty
+    request.method.must_equal :get
+  end
+
+  it 'should keep uri#query consistent' do
+    request = Commute::Http::Request.new nil
+    request.query[:limit] = 10
+    request.uri.query.must_equal 'limit%3D10'
+    request.query[:index] = 20
+    request.uri.query.must_equal 'limit%3D10%26index%3D20'
+  end
+end

data/spec/commute/core/layer_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+require 'commute/core/builder'
+require 'commute/core/http'
+require 'commute/core/util/path'
+require 'commute/core/layer'
+
+describe Commute::Layer do
+
+  it 'should have a name' do
+    layer = Commute::Layer.new proc {}, :test
+    layer.name.must_equal :test
+  end
+
+  it 'should figure out the name is none was given' do
+    # With an instance var.
+    klass = Class.new do
+      @name = :test
+    end
+    layer = Commute::Layer.new klass.new
+    layer.name.must_equal :test
+    # With a method.
+    klass = Class.new do
+      def name; :test; end
+    end
+    layer = Commute::Layer.new klass.new
+    layer.name.must_equal :test
+  end
+
+  describe '#call' do
+
+    it 'should auto-add context options to the options hash' do
+      context  = Commute::Context.new(nil).with auth: { key: 'secret' }
+      request  = Commute::Layer::Request.new Commute::Http::Request.new(context)
+      callable = mock
+      router   = mock
+      callable.expects(:call).with(router, request, key: 'secret')
+      Commute::Layer.new(callable, :auth).call router, request
+    end
+  end
+
+  describe '#callable' do
+    let(:context) { Commute::Context.new(nil) }
+
+    it 'should return false if the layer is disabled' do
+      Commute::Layer.new(proc {}, :test).callable?(context.disable(:test).context).must_equal false
+    end
+
+    it 'should return false if the layer has no callable' do
+      Commute::Layer.new(nil, :test).callable?(context).must_equal false
+    end
+
+    it 'should return true otherwise' do
+      Commute::Layer.new(proc {}, :test).callable?(context).must_equal true
+    end
+  end
+end
+
+describe Commute::Layer::Communication do
+
+  it 'should hold an underlaying http request/response' do
+    http = Commute::Http::Request.new(nil)
+    Commute::Layer::Request.new(http).http.must_equal http
+  end
+end
+
+describe Commute::Layer::Request do
+
+  it 'should be respondable' do
+    receiver = proc {}
+    http_request = Commute::Http::Request.new(nil)
+    request = Commute::Layer::Request.new(http_request)
+    http_response = Commute::Http::Response.new(request)
+    status = Commute::Status.ok
+    request.on(:response, &receiver)
+    receiver.expects(:call).with do |response, _status|
+      response.http == http_response && _status == status
+    end
+    request.respond http_response, status
+  end
+end

data/spec/commute/core/sequence_spec.rb

@@ -3,188 +3,74 @@ require 'commute/core/sequence'
 
 describe Commute::Sequence do
 
-  let(:sequence) { Commute::Sequence.new }
+  let(:sequence) { Commute::Sequence.new(:test) }
 
-  let(:processor1) {
-    lambda { |result, subject, options = {}| result + 1 }
-  }
-
-  let(:processor2) {
-    lambda { |result, subject, options = {}| result * 2 }
-  }
-
-  let(:processor3) {
-    Class.new {
-      @id = :test
-
-      def call result, subject, options = {}
-        result ** options[:power]
-      end
-    }.new
-  }
+  it 'should have a name' do
+    sequence.name.must_equal :test
+  end
 
   describe '#new' do
+    it 'should be empty' do
+      sequence.size.must_equal 0
+    end
+
     it 'should alter the sequence when a block is provided' do
-      sequence = Commute::Sequence.new do |s|
-        s.append processor1
-      end
-      sequence.processors.size.must_equal 1
+      Commute::Sequence.new(:test) { |s|
+        s.append proc {}
+      }.size.must_equal 1
+      Commute::Sequence.new(:test) {
+        append proc {}
+        append proc {}
+      }.size.must_equal 2
     end
   end
 
   describe '#alter' do
     it 'should alter the sequence in a block when the arity is 1' do
-      sequence.alter do |s|
-        s.append processor1
-      end
-      sequence.processors.size.must_equal 1
+      sequence.alter { |s|
+        s.append proc {}
+      }.size.must_equal 1
     end
 
     it 'should evaluate the block when the arity is 0' do
-      sequence.alter do
-        append Proc.new { |n| n.data += 1 }
-      end
-      sequence.processors.size.must_equal 1
-    end
-  end
-
-  describe '#processors' do
-    it 'should return an empty array when there are no processors' do
-      sequence.processors.must_equal []
-    end
-
-    it 'should not return a modifiable array' do
-      sequence.processors << 'test'
-      sequence.processors.must_be_empty
-    end
-  end
-
-  describe '#processors=' do
-
-    it 'should not exist' do
-      Proc.new { sequence.processors = nil }.must_raise NoMethodError
-    end
-  end
-
-  describe '#call' do
-    let(:processor1) do
-      Proc.new do |commuter|
-        commuter.change { |n| n+1 }
-      end
-    end
-
-    let(:processor2) do
-      Proc.new do |commuter, operation|
-        commuter.change { |n| n.send operation, n }
-      end
-    end
-
-    let(:commuter) { Commute::Commuter.new mock, 1 }
-
-    it 'should call all processors' do
-      commuter.expects(:parameters).with(nil).never
-      commuter.expects(:parameters).with(:operator).returns(:**)
-      sequence.append(processor1)
-      sequence.append(processor2, as: :operator)
-      sequence.call commuter
-      commuter.get.must_equal 4
-    end
-
-    # This is not tested implicitely due to the Proc usage.
-    it 'should call processors with the correct number of arguments' do
-      commuter.expects(:parameters).with(:operator).returns(:+)
-      processor1 = mock
-      processor1.expects(:call).with(commuter)
-      processor2 = mock
-      processor2.expects(:call).with(commuter, :+)
-      sequence.append processor1
-      sequence.append processor2, as: :operator
-      sequence.call commuter
-    end
-
-    it 'should be a processor itself' do
-      commuter.expects(:parameters).with(:operator).returns(:**)
-
-      subsequence = Commute::Sequence.new do |s|
-        s.append processor1
-      end
-
-      sequence = Commute::Sequence.new do |s|
-        s.append subsequence
-        s.append processor2, as: :operator
-      end
-
-      sequence.call commuter
-      commuter.get.must_equal 4
-    end
-
-    it 'should return nothing' do
-      Commute::Sequence.new { |s|
-        s.append processor1
-      }.call(commuter).must_equal nil
+      sequence.alter {
+        append proc {}
+      }.size.must_equal 1
     end
   end
 
   describe '#append' do
     it 'should append the processor to the tail' do
-      sequence.append processor1
-      sequence.processors.must_equal [processor1]
-      assert_equal sequence.append(processor2),  processor2
-      sequence.processors.must_equal [processor1, processor2]
-    end
-
-    it 'should be able to override the default processor id' do
-      sequence.append processor1, as: :increment
-      sequence.at(:increment).call(1, nil).must_equal 2
-
-      sequence.append processor3, as: :power
-      sequence.at(:power).must_equal processor3
+      layer1 = sequence.append proc {}
+      sequence.must_equal [layer1]
+      layer2 = sequence.append proc {}
+      sequence.must_equal [layer1, layer2]
     end
 
     it 'should be able to append after a specified processor' do
-      sequence.append processor1, as: :increment
-      sequence.append processor2
+      layer1 = sequence.append proc {}, as: :action1
+      layer3 = sequence.append proc {}
 
-      sequence.append processor3, as: :power, after: :increment
-      sequence.processors.must_equal [processor1, processor3, processor2]
+      layer2 = sequence.append proc {}, as: :action2, after: :action1
+      sequence.must_equal [layer1, layer2, layer3]
     end
   end
 
   describe '#remove' do
     before do
-      sequence.append processor1
-      sequence.append processor2, as: :multiplier
-    end
-
-    it 'should remove the processor if the processor itself is given' do
-      processor = sequence.remove processor1
-      (processor == processor1).must_equal true
-      sequence.processors.must_equal [processor2]
-      assert_equal sequence.at(:multiplier), processor2
+      @layer1 = sequence.append proc {}
+      @layer2 = sequence.append proc {}, as: :action
     end
 
     it 'should remove the processor if its id is given' do
-      processor = sequence.remove :multiplier
-      (processor == processor2).must_equal true
-      sequence.processors.must_equal [processor1]
-      sequence.at(:multiplier).must_be_nil
+      sequence.remove(:action).must_equal @layer2
+      sequence.must_equal [@layer1]
     end
   end
 
-  describe '#at' do
-    it 'should index processors with a default id' do
-      sequence.append processor3
-      sequence.at(:test).must_equal processor3
-    end
-  end
-
-  describe '#dup' do
-    it 'should duplicate the sequence' do
-      sequence.append processor1
-      cloned = sequence.dup
-      cloned.append processor2
-      sequence.processors.size.must_equal 1
-      cloned.processors.size.must_equal 2
+  describe '#call' do
+    it 'should lazily push the sequence on the path' do
+      skip
     end
   end
 end

data/spec/commute/core/stack_spec.rb

@@ -4,93 +4,43 @@ require 'commute/core/stack'
 
 describe Commute::Stack do
 
-  let(:sequence) do
-    Commute::Sequence.new do
-      append Proc.new { |n| n.data += 1 }
-    end
-  end
-
-  let(:stack) do
-    Commute::Stack.new do |stack, main|
-    end
-  end
-
-  describe '#initialize' do
-    describe 'when no sequence is given' do
-      it 'should yield the main sequence for the stack when the arity is 1' do
-        stack = Commute::Stack.new do |sequence|
-          sequence.append Proc.new {}
+  let(:stack) { Commute::Stack.new }
+
+  # A Layer that forwards to the next.
+  let(:forward_layer) { proc { |router, request, options = {}|
+    request.pipe router.call(request.http) { |response, status|
+      response.pipe request.respond(response.http, status)
+    }
+  }}
+
+  # A layer that echoes all data.
+  let(:echo_layer) { proc { |router, request, options = {}|
+    request.pipe request.respond(Commute::Http::Response.new(request), Commute::Status.ok)
+  }}
+
+  describe '#call' do
+    describe 'with a forward and echo layer' do
+      it 'should echo all data' do
+        # Append a forward and echo layer to the main sequence.
+        stack.sequence do |s|
+          s.append forward_layer
+          s.append forward_layer
+          s.append stack.sequence(:echo)
         end
-        stack.sequence.processors.size.must_equal 1
-      end
-
-      it 'should yield the stack and the main sequence when the arity is 2' do
-        stack = Commute::Stack.new do |stack, sequence|
-          sequence.append Proc.new {}
+        stack.sequence(:echo) do |s|
+          s.append echo_layer
         end
-        stack.sequence.processors.size.must_equal 1
-      end
-    end
-
-    describe 'when a sequence is given' do
-      it 'should use that sequence' do
-        sequence = Commute::Sequence.new do
-          append Proc.new {}
-        end
-        stack = Commute::Stack.new sequence
-        stack.sequence.processors.size.must_equal 1
-      end
-    end
-  end
-
-  describe '#add' do
-    it 'should add a sequence to the stack by name' do
-      stack.add sequence, :calculation
-      stack.sequence(:calculation).must_equal sequence
-    end
-  end
-
-  describe '#sequence' do
-    it 'should add the sequence when it was not found' do
-      stack.sequence(:calculation) do
-        append Proc.new { |c| c.set(c.get + 1) }
-      end
-
-      stack.sequence(:calculation).processors.size.must_equal 1
-    end
-  end
-
-  describe '#sequencer' do
-    it 'should allow us to embed a sequence in a sequence' do
-      stack = Commute::Stack.new do |stack, sequence|
-        sequence.append Commute::Sequencer.new(:calculation)
-        sequence.append Proc.new { |c|
-          c.change { |n| "The result is #{n}" }
-        }
-
-        stack.sequence(:calculation) do
-          append Proc.new { |c| c.set(c.get + 1) }
-          append Proc.new { |c| c.set(c.get + 2) }
+        # Call the stack.
+        context = Commute::Context.new stack
+        request = stack.call Commute::Http::Request.new(context) do |response, status|
+          puts 'response!'
+          response.on(:data) { |chunk| puts chunk }
+          response.on(:end) { puts 'end!'}
         end
+        request.write 1
+        request.write 2
+        request.end
       end
-      commuter = Commute::Commuter.new(Commute::Context.new(stack), 1)
-      stack.call(commuter)
-      commuter.get.must_equal 'The result is 4'
-    end
-  end
-
-  describe '#dup' do
-    it 'should duplicate the stack and all its sequences' do
-      stack.add sequence, :calculation
-      cloned = stack.dup.alter do
-        sequence.append Proc.new {}
-
-        sequence(:calculation).append Proc.new {}
-      end
-      stack.sequence.processors.size.must_equal 0
-      stack.sequence(:calculation).processors.size.must_equal 1
-      cloned.sequence.processors.size.must_equal 1
-      cloned.sequence(:calculation).processors.size.must_equal 2
     end
   end
 end

data/spec/commute/core/util/event_emitter_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'commute/core/util/event_emitter'
+
+describe Commute::EventEmitter do
+
+  let(:emitter) {
+    Class.new { include Commute::EventEmitter }.new
+  }
+
+  let(:handler1) { proc {} }
+  let(:handler2) { proc {} }
+  let(:handler3) { proc {} }
+
+  it 'should notify event handlers for one event' do
+    [handler1, handler2].each do |handler|
+      handler.expects(:call).with :test, 1
+    end
+    emitter.on :data, &handler1
+    emitter.on :data, &handler2
+    emitter.send :emit, :data, :test, 1
+  end
+
+  it 'should notify event handlers for multiple events' do
+    [handler1, handler2].each do |handler|
+      handler.expects(:call).with(:test, 1).once
+    end
+    handler3.expects(:call).once
+    emitter.on :data, &handler1
+    emitter.on :data, &handler2
+    emitter.on :end, &handler3
+    emitter.send :emit, :data, :test, 1
+    emitter.send :emit, :end
+  end
+end

data/spec/commute/core/util/path_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'commute/core/util/path'
+
+describe Commute::Path do
+
+  Path = Commute::Path
+
+  describe 'with a single route' do
+
+    it 'should walk the entire route' do
+      path = Path.new([1,2,3].each)
+      [path.succ, path.succ, path.succ].must_equal [1,2,3]
+    end
+  end
+
+  describe 'with one detour' do
+
+    it 'should walk the main route, the detour and the rest of the main route' do
+      router = Path.new([1,2,3].each)
+      router.succ.must_equal 1
+      router.succ.must_equal 2
+      router << ['a', 'b'].each
+      router.succ.must_equal 'a'
+      router.succ.must_equal 'b'
+      router.succ.must_equal 3
+      router.succ.must_equal nil
+    end
+  end
+end

data/spec/commute/core/util/stream_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+require 'commute/core/util/stream'
+
+describe Commute::Stream do
+
+  let(:stream) {
+    Class.new { include Commute::Stream }.new
+  }
+
+  let(:handler) { proc {} }
+
+  describe '#new' do
+    it 'should be writeable' do
+      stream.writeable?.must_equal true
+    end
+  end
+
+  describe '#write' do
+    it 'should write data to the stream' do
+      handler.expects(:call).twice
+      stream.on :data, &handler
+      stream.write 1
+      stream.write 2
+      stream.writeable?.must_equal true
+    end
+  end
+
+  describe '#end' do
+    it 'should end the stream' do
+      data_handler = proc {}
+      end_handler = proc {}
+      stream.on :data, &data_handler
+      stream.on :end, &end_handler
+      data_handler.expects(:call).twice
+      end_handler.expects(:call).once
+      stream.write 1
+      stream.write 2
+      stream.end
+      stream.write(3).must_equal nil
+      stream.writeable?.must_equal false
+    end
+  end
+
+  describe '#buffer' do
+    it 'should buffer all stream data when a buffer is given' do
+      buffer = []
+      stream >> buffer
+      0.upto(3) { |i| stream.write i }
+      stream.end
+      buffer.must_equal [0,1,2,3]
+    end
+
+    it 'should buffer all stream data when no buffer is given' do
+      stream.buffer do |buffer|
+        buffer.must_equal [0,1,2,3]
+      end
+      0.upto(3) { |i| stream.write i }
+    end
+  end
+
+  describe '#pipe' do
+    it 'should pipe the stream to an other stream' do
+      destination = mock
+      streaming = sequence 'streaming'
+      destination.expects(:write).with(1).in_sequence streaming
+      destination.expects(:write).with(2).in_sequence streaming
+      destination.expects(:end).in_sequence streaming
+      stream.pipe destination
+      stream.write 1
+      stream.write 2
+      stream.end
+    end
+  end
+
+  describe '#map' do
+    it 'should map all data in a stream' do
+      buffer = []
+      output = stream.
+        map { |i| i*2 }.
+        reject { |i| i % 3 == 0 }.
+        inject(0, &:+) >> buffer
+      1.upto(5) do |i|
+        stream.write i
+      end
+      stream.end
+      buffer.must_equal [24]
+    end
+  end
+end