rachinations 0.0.1

data/testing/spec/edge_spec.rb

@@ -0,0 +1,256 @@
+require_relative 'spec_helper'
+
+describe Edge do
+
+  describe '#initialize' do
+
+    it 'can be created' do
+
+      # i only want to test edge methods so I'll use a mock object and stub the method I need
+      # to call, namely :name.
+
+      from = double(:name => 'node1')
+
+      to = double(:name => 'node2')
+
+      edge = Edge.new name: 'edge1', from: from, to: to
+
+    end
+
+    it "is created with the expected defaults in case attributes aren't provided" do
+      edge = Edge.new name: 'edge', from: Object.new, to: Object.new
+
+      expect(edge.label).to eq 1
+      expect(edge.types).to eq []
+
+    end
+
+    it 'can be created with types' do
+
+      from = double(:name => 'node1')
+      to = double(:name => 'node2')
+
+      edge = Edge.new name: 'edge1', from: from, to: to, types: [Blue, Black]
+
+      expect(edge.name).to eq('edge1')
+      expect(edge.from).to eq(from)
+      expect(edge.to).to eq(to)
+      expect(edge.support?(Blue)).to be true
+      expect(edge.support?(Black)).to be true
+
+    end
+
+    it 'can be assigned an integer label' do
+
+      from = double(:name => 'node1')
+      to = double(:name => 'node2')
+
+      edge = Edge.new name: 'edge1', from: from, to: to, types: [Blue, Red], label: 5
+
+      expect(edge.name).to eq 'edge1'
+
+      expect(edge.from).to eq from
+      expect(edge.to).to eq to
+
+      expect(edge.support?(Blue)).to be true
+      expect(edge.support?(Black)).not_to be true
+      expect(edge.support?(Red)).to be true
+
+      expect(edge.label).to be 5
+
+    end
+
+  end
+
+  describe '#test_ping?' do
+    before(:each) do
+      @strategy=double(:condition => proc {})
+      @to = instance_double(ResourcefulNode, :disabled? => false, :types => double())
+    end
+
+    context 'when require_all' do
+
+      it 'is false when no resources can pass' do
+        from = instance_double(ResourcefulNode, :resource_count => 0, :disabled? => false)
+
+        edge = Edge.new :name => 'e', :from => from, :to => @to
+        expect(edge).to receive(:strategy).and_return(@strategy)
+        expect(edge.test_ping?(true)).to eq false
+
+      end
+
+      it 'is false when some but not all required resources can pass' do
+        from = instance_double(ResourcefulNode, :resource_count => 5, :disabled? => false)
+
+        edge = Edge.new :name => 'e', :from => from, :to => @to, :label => 8
+        expect(edge).to receive(:strategy).and_return(@strategy)
+        expect(edge.test_ping?(true)).to eq false
+      end
+
+      it 'is true when the exact number of required resources are available to be moved' do
+        from = instance_double(ResourcefulNode, :resource_count => 8, :disabled? => false)
+
+        edge = Edge.new :name => 'e', :from => from, :to => @to, :label => 8
+        expect(edge).to receive(:strategy).and_return(@strategy)
+        expect(edge.test_ping?(true)).to eq true
+      end
+
+      it 'is true when the more resources than required are available to be moved' do
+        from = instance_double(ResourcefulNode, :resource_count => 3, :disabled? => false)
+
+        edge = Edge.new :name => 'e', :from => from, :to => @to, :label => 2
+        expect(edge).to receive(:strategy).and_return(@strategy)
+        expect(edge.test_ping?(true)).to eq true
+      end
+
+    end
+
+    context 'when not require_all' do
+
+      it 'is false when no resources are available at all' do
+        from = instance_double(ResourcefulNode, :resource_count => 0, :disabled? => false)
+
+        edge = Edge.new :name => 'e', :from => from, :to => @to
+        expect(edge).to receive(:strategy).and_return(@strategy)
+        expect(edge.test_ping?(false)).to eq false
+      end
+
+      it 'is true if at least one resource is available' do
+        from = instance_double(ResourcefulNode, :resource_count => 1, :disabled? => false)
+
+        edge = Edge.new :name => 'e', :from => from, :to => @to, :label => 8
+        expect(edge).to receive(:strategy).and_return(@strategy)
+        expect(edge.test_ping?(false)).to eq true
+      end
+
+    end
+
+  end
+
+  describe '#pull_expression' do
+
+    before(:each) do
+      @e = Edge.new name: 'e', from: double(), to: double()
+
+      @strat = instance_double(ValidTypes)
+      allow(@e).to receive(:strategy).and_return(@strat)
+    end
+
+    it 'forwards the call to a strategy' do
+      blk=proc { |r| true }
+      expect(@strat).to receive(:pull_condition).and_return(blk)
+      @e.pull_expression
+    end
+
+  end
+
+  describe '#push_expression' do
+    before(:each) do
+      @e = Edge.new name: 'e', from: double(), to: double()
+
+      @strat = instance_double(ValidTypes)
+      allow(@e).to receive(:strategy).and_return(@strat)
+    end
+
+    it 'forwards the call to a strategy' do
+      blk=proc { |r| true }
+      expect(@strat).to receive(:push_condition).and_return(blk)
+      received_blk = @e.push_expression
+      expect(received_blk).to be blk
+
+    end
+  end
+
+  describe '#pull!' do
+
+    context 'when edge has label 1' do
+
+      before(:each) do
+        @p1 = instance_double(Node, types: [], enabled?: true)
+        @p2 = instance_double(Node, types: [], enabled?: true)
+        @e = Edge.new name: 'e', from: @p1, to: @p2
+      end
+
+      it 'sends take_resource! with a block to to_node' do
+
+
+      end
+
+      it 'returns a resource in case it succeeded' do
+
+      end
+
+      it 'raises an exception if it cannot pull the one resource' do
+
+      end
+
+    end
+
+    context 'when edge has label greater than 1' do
+
+      it 'sends #get_block to self before pulling anything each time' do
+
+      end
+
+      it 'sends #take_resource! with a block from node as many times as it has' do
+        # as many times as the label tells it to
+
+      end
+
+      it 'raises no exception if at least one resource (but not all) got pulled' do
+        # because the semantics of a label is 'at most' that many resources
+        # if not all could be pulled, it's not an error.
+      end
+
+      it 'raises exception if no resources could be pulled' do
+
+      end
+
+    end
+
+    it 'does not send put_resource! to the caller' do
+      # it merely returns the resource
+
+    end
+
+
+  end
+
+  describe '#push!' do
+
+
+    context 'when edge has label 1' do
+
+      before(:each) do
+        @p1 = instance_double(Node,name:'n', types: [], enabled?: true)
+        @p2 = instance_double(Node,name:'n2', types: [], enabled?: true)
+        @e = Edge.new name: 'e', from: @p1, to: @p2
+      end
+      it 'sends put_resource! to to_node' do
+        # passing the same parameter it was given by the caller
+        res = instance_double(Token,type:Token)
+        expect(@p2).to receive(:put_resource!)
+        @e.push!(res)
+
+      end
+
+      it 'raises an exception if the push was unsuccessful' do
+        # wrap the exception raised by to node or let it bubble up?
+      end
+
+
+    end
+
+    context 'when edge has label greater than 1' do
+
+      it 'raises error if no resources could be sent' do
+
+      end
+
+    end
+
+
+  end
+
+
+end

data/testing/spec/hash_init_spec.rb

@@ -0,0 +1,59 @@
+require_relative 'spec_helper'
+
+# a class double so as not to bring in extra stuff we don't want to test
+#http://martinfowler.com/articles/mocksArentStubs.html
+class Double
+  include HashInit
+
+  def options
+    #isto é um array com 2 symbols e uma hash
+    [:foo, :registro, bar: :required]
+  end
+
+  def defaults
+    {
+        foo: 'foo',
+        registro: 'foobar'
+    }
+  end
+
+  def aliases
+    { resistro: :registro, boo: :bar }
+  end
+
+end
+
+
+describe 'Passing of options to Nodes' do
+
+  it 'notifies the user when no parameters were given' do
+    expect{Double.new}.to raise_error BadOptions
+  end
+
+  it 'notifies the user when given parameter was not a hash' do
+    expect{Double.new Array.new}.to raise_error BadOptions
+    expect{Double.new Object.new}.to raise_error BadOptions
+    expect{Double.new String.new}.to raise_error BadOptions
+  end
+
+  it 'runs ok on simple case' do
+    expect{Double.new bar: 'someval'}.not_to raise_error
+  end
+
+  it 'raises errors if required options are not given' do
+    expect{Double.new foo: 'foo'}.to raise_error BadOptions
+  end
+
+  it 'raises errors on invalid options' do
+    expect{Double.new bar: 'name', ajsdasdsad: :alkjdasdsad}.to raise_error BadOptions
+  end
+
+  it 'correctly infers aliases for non-required options' do
+    expect{Double.new bar: 'bar', resistro: 'foo bar'}.not_to raise_error
+  end
+
+  it 'correctly infers aliases for required options' do
+    expect{Double.new boo: 'bar'}.not_to raise_error
+  end
+
+end

data/testing/spec/node_spec.rb

@@ -0,0 +1,31 @@
+require_relative 'spec_helper'
+
+describe Node do
+
+  it 'knows which edges are incoming' do
+
+    n = Node.new
+
+    e = double(:to => n)
+
+    n.attach_edge(e)
+
+    expect(n.edges).to include e
+    expect(n.incoming_edges).to include e
+
+  end
+
+  it 'knows which edges are outgoing' do
+
+    n = Node.new
+
+    e = double(:from => n)
+
+    n.attach_edge(e)
+
+    expect(n.edges).to include e
+    expect(n.outgoing_edges).to include e
+
+  end
+
+end

data/testing/spec/non_deterministic_diagram_spec.rb

@@ -0,0 +1,112 @@
+require_relative 'spec_helper'
+
+
+describe NonDeterministicDiagram do
+
+  it "runs noreporting" do
+    generator = NonDeterministicDiagram.new('1to2')
+    #generator.extend(Verbose)
+
+    generator.add_node! Pool, {
+        name: 'g1',
+        activation: :automatic,
+        initial_value: 5,
+        mode: :push
+    }
+
+    generator.add_node! Pool, {
+        name: 'g2',
+        activation: :automatic,
+        mode: :push
+    }
+
+    generator.add_node! Pool, {
+        name: 'g3'
+    }
+
+    generator.add_edge! Edge, {
+        name: 'c1',
+        from: 'g1',
+        to: 'g2'
+    }
+
+    generator.add_edge! Edge, {
+        name: 'c2',
+        from: 'g1',
+        to: 'g3',
+    }
+
+
+    generator.add_edge! Edge, {
+        name: 'c3',
+        from: 'g2',
+        to: 'g1',
+    }
+
+    generator.run!(100) #should be enough
+
+    # don´t know what to test...
+    expect(generator.get_node('g3').resource_count).to eq 5
+
+  end
+
+  include DSL
+
+  it ' makes a train run' do
+
+
+    d = NonDeterministicDiagram.new 'dia'
+
+    d.add_node! Pool, {
+        name: 'p1',
+        mode: :push_any,
+        activation: :automatic,
+        initial_value: 8
+    }
+
+    d.add_node! Pool, {
+        name: 'p2',
+        mode: :push_any,
+        activation: :automatic
+    }
+
+    d.add_node! Pool, {
+        name: 'p3',
+        mode: :push_any,
+        activation: :automatic
+    }
+
+    d.add_node! Pool, {
+        name: 'p4',
+        mode: :push_any,
+        activation: :automatic
+    }
+
+    d.add_edge! Edge, {
+        name: 'e1',
+        from: 'p1',
+        to: 'p2'
+    }
+    d.add_edge! Edge, {
+        name: 'e2',
+        from: 'p2',
+        to: 'p3'
+    }
+    d.add_edge! Edge, {
+        name: 'e3',
+        from: 'p3',
+        to: 'p4'
+    }
+
+
+    d.run!(200)
+
+    expect(d.get_node('p1').resource_count).to eq 0
+    expect(d.get_node('p2').resource_count).to eq 0
+    expect(d.get_node('p3').resource_count).to eq 0
+    expect(d.get_node('p4').resource_count).to eq 8
+
+  end
+
+
+end