rachinations 0.0.1

data/testing/spec/pool_spec.rb

@@ -0,0 +1,233 @@
+require_relative 'spec_helper'
+
+describe Pool do
+
+  it 'is created with just a name attribute and has the expected default attributes' do
+    obj = Pool.new name: 'some name'
+
+    expect(obj.passive?).to eq true
+    expect(obj.pull?).to eq true
+    expect(obj.resource_count).to eq 0
+
+  end
+
+  it 'knows its name' do
+
+    obj = Pool.new name: 'foo'
+
+    expect(obj).to respond_to :name
+    expect(obj.name).to eq 'foo'
+  end
+
+  it 'cannot have its name set after creation' do
+
+    obj = Pool.new name: 'bar'
+    expect(obj).not_to respond_to :name=
+
+  end
+
+  it 'supports simple integers as resources' do
+
+    p=Pool.new name: 'baz', initial_value: 10
+
+    expect(p.resource_count).to eq 10
+
+  end
+
+  it 'supports types during instantiation' do
+
+    #note that there is no check whether this class is suited to play the role of a Token...
+
+    expect { Pool.new name: 'qux', types: [Peach] }.not_to raise_error
+
+  end
+
+  it "knows that having initial values for some types implies having those types even if the user didn't explicitly added them" do
+
+    p = Pool.new name: 'foo', initial_values: {Peach => 6, Mango => 7}
+
+    expect(p.support?(Peach)).to eq true
+    expect(p.support?(Mango)).to eq true
+
+  end
+
+  it 'can be set to automatic upon instantiation' do
+    Pool.new name: 'bar', activation: :automatic
+  end
+
+  it 'knows how many resources were added' do
+
+    p1 = Pool.new name: 'typed pool'
+    5.times { p1.put_resource! Token.new }
+    p1.unlock_resources!
+    2.times { p1.take_resource! }
+
+
+    expect(p1.resources_added).to eq 5
+    expect(p1.resources_removed).to eq 2
+    expect(p1.resource_count).to eq 3
+
+  end
+
+
+  it 'is enabled by default' do
+
+    p2 = Pool.new name: 'simpler yet'
+
+    expect(p2.enabled?).to eq true
+
+  end
+
+  describe '#resource_count' do
+
+    before(:each) do
+      @untyped = Pool.new name: 'p', initial_value: 10
+      @typed = Pool.new name: 'p', initial_value: {Peach => 10, Lemon => 5}
+    end
+
+    it 'works with no params' do
+      expect(@typed.resource_count).to eq 15
+      expect(@untyped.resource_count).to eq 10
+    end
+
+    it 'raises an error when it is asked about an unsupported type and it is typed' do
+      expect { @typed.resource_count(Mango) }.to raise_error UnsupportedTypeError
+    end
+
+    it 'just returns zero if it is untyped and it is asked about a type' do
+      expect(@untyped.resource_count(Mango)).to eq 0
+    end
+
+    it 'otherwise works with one type param' do
+      expect(@typed.resource_count(Peach)).to eq 10
+    end
+
+    it 'accepts a single block' do
+      expect(@typed.resource_count { |r| r.is_type? Peach }).to eq 10
+      expect(@untyped.resource_count { true }).to eq 10
+
+      # if user sent a block. he prolly knows what he's doing so no errors.
+      expect(@typed.resource_count { |r| r.is_type? Football }).to eq 0
+    end
+
+    it 'errors if given both a type and a block' do
+      expect { @typed.resource_count(Peach) { |r| r.is_type? Mango } }.to raise_error ArgumentError
+    end
+
+    it 'also errors if some other nonsense is passed' do
+      expect { @typed.resource_count(Hash.new) }.to raise_error ArgumentError
+      expect { @untyped.resource_count('Foo') }.to raise_error ArgumentError
+    end
+
+  end
+
+  describe '#take_resource!' do
+
+
+  end
+
+  describe '#put_resource!' do
+    before(:each) do
+      @p = Pool.new name: 'p'
+      @res = instance_double(Token, lock!: @res, :unlocked? => true)
+    end
+    it 'blocks the resource upon receiving it' do
+
+      expect(@res).to receive(:lock!)
+
+      @p.put_resource!(@res)
+
+    end
+
+    it 'adds the resource to the store' do
+      bag_dbl = instance_double(ResourceBag)
+      expect(@p).to receive(:resources).and_return(bag_dbl)
+      expect(bag_dbl).to receive(:add!)
+
+      @p.put_resource!(Token.new)
+    end
+
+    it 'fires triggers' do
+      expect(@p).to receive(:fire_triggers!)
+      @p.put_resource!(Token.new)
+    end
+
+  end
+
+  describe '#trigger!' do
+
+
+    context 'when :push_any' do
+
+      before(:each) do
+
+        @p = Pool.new name: 'p', mode: :push_any
+
+        @e = instance_double(Edge, from: @p, to: double(), label: 1)
+        allow(@e).to receive_messages([:push!])
+
+        @p.attach_edge!(@e)
+
+      end
+
+      it 'asks outgoing edges for blocks' do
+
+        expect(@e).to receive(:push_expression).and_return(proc { |r| true == true })
+
+        @p.trigger!
+
+      end
+
+      it 'removes resources from self if given a suitable block' do
+        expect(@e).to receive(:push_expression).and_return(proc { |r| true })
+
+        expect(@p).to receive(:remove_resource!)
+
+        @p.trigger!
+
+      end
+
+      it 'calls push! on edge if it succeeded in removing from self the needed resource for that edge' do
+
+        expect(@e).to receive(:push_expression).and_return( proc{ true==true } )
+
+        res = instance_double(Token)
+
+        expect(@p).to receive(:remove_resource!).and_return(res)
+
+        expect(@e).to receive(:push!).with(res)
+
+        @p.trigger!
+
+      end
+
+      it 'does not call push! on edge if it cannot provide the needed resource' do
+        expect(@e).to receive(:push_expression).and_return( proc{ true })
+
+        expect(@p).to receive(:remove_resource!).and_raise(RuntimeError)
+
+        expect(@e).not_to receive(:push!)
+
+        @p.trigger!
+
+      end
+
+    end
+
+    context 'when :pull_any' do
+
+
+    end
+
+    context 'when :push_all' do
+
+    end
+
+    context 'when :pull_all' do
+
+    end
+
+
+  end
+
+end

data/testing/spec/source_spec.rb

@@ -0,0 +1,132 @@
+require_relative 'spec_helper'
+
+describe 'Source' do
+
+  describe '#initialize' do
+
+    it 'is push_any automatic with no types by default' do
+
+      s = Source.new name: 'source'
+
+      expect(s.typed?).to eq false
+      expect(s.automatic?).to eq true
+      expect(s.push?).to eq true
+      expect(s.any?).to eq true
+
+    end
+
+    it 'raises an error if user tries to give it an initial_value' do
+      #sources have no initial value
+      expect { Source.new name: 'mysource', initial_value: 10 }.to raise_error BadOptions
+    end
+
+
+  end
+
+
+  describe '#support?' do
+
+    it "supports anything if it's untyped" do
+      s = Source.new name: 'foo'
+
+      expect(s.support?(Peach)).to eq true
+
+    end
+
+    it "supports only the given type and no other types if it's been given a specific type" do
+
+      s = Source.new name: 'foo', type: Peach
+
+      expect(s.support?(Mango)).to eq false
+      expect(s.support?(Peach)).to eq true
+
+    end
+
+
+  end
+
+
+  describe '#take_resource!' do
+
+    it "provides a typeless resource (Token) if it it's untyped" do
+
+      s = Source.new name: 'foo'
+
+      expect(s.take_resource!).to be_a(Token)
+
+    end
+
+    it "provides a typed resource if it supports that type" do
+
+      s = Source.new name: 'foo', type: Green
+
+      expect(s.take_resource!(Green)).to be_a(Green)
+
+    end
+
+    it "keeps giving out resources forever, and each resource is a different object" do
+
+      s = Source.new name: 'foo', type: Blue
+
+      obj_ids = []
+
+      #i've tested this with up to 10000 loops.
+      # but i keep this 100 just to make the whole
+      # test suite run faster.
+      100.times do
+
+        res = s.take_resource!(Blue)
+
+        expect(res).to be_a(Blue)
+
+        expect(obj_ids).not_to include(res.object_id)
+
+        obj_ids.push(res.object_id)
+
+
+      end
+
+    end
+
+  end
+
+  describe '#trigger!' do
+
+    context 'when :push_any' do
+
+      before(:each) do
+
+        @s = Source.new name: 's'
+
+        @e1 = instance_double(Edge, from: @s, to: double(), label: 1)
+
+        @e2 = instance_double(Edge, from: @s, to: double(), label: 1)
+
+        @s.attach_edge!(@e1)
+        @s.attach_edge!(@e2)
+
+
+      end
+
+      it 'sends a push to outgoing edges(in random order)' do
+
+        expect(@e1).to receive(:push_expression).and_return( proc{true==true} )
+        expect(@e2).to receive(:push_expression).and_return( proc{true==true} )
+
+        expect(@e1).to receive(:push!)
+        expect(@e2).to receive(:push!)
+
+        @s.trigger!
+
+      end
+
+    end
+
+    context 'when :push_all' do
+
+    end
+
+  end
+
+
+end

data/testing/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'coveralls'
+Coveralls.wear!
+
+# so that i can require stuff as if these dirctories were in ruby's default PATH
+#$: << File.expand_path(File.dirname(__FILE__))+"/../../domain"
+#$: << File.expand_path(File.dirname(__FILE__))+"/../../dsl"
+
+require 'rspec'
+
+# RSpec.configure do |config|
+#   config.color_enabled = true
+#   config.default_path = 'testing/spec'
+# end
+
+require 'rachinations'
+
+#resource classes to be used in tests
+Blue=Class.new(Token)
+Black=Class.new(Token)
+Green=Class.new(Token)
+Red=Class.new(Token)
+Yellow=Class.new(Token)
+
+
+Football=Class.new(Token)
+Baseball=Class.new(Token)
+Basketball=Class.new(Token)
+
+Mango=Class.new(Token)
+Peach=Class.new(Token)
+Banana=Class.new(Token)
+Lemon=Class.new(Token)
+
+

data/testing/spec/xexeo_spec.rb

@@ -0,0 +1,193 @@
+require_relative 'spec_helper'
+
+#models in testing/simulations, rewritten as specs
+
+describe Diagram do
+
+  it "runs modelo1" do
+
+    n=diagram 'test_diagram' do
+      node 'source', Source
+      node 'pool1', Pool
+      edge 'edge1', Edge, 'source', 'pool1'
+    end
+
+    d = Diagram.new('one source one pool')
+
+    n.run!(5)
+
+  end
+
+  it "runs modelo2" do
+
+    generator = Diagram.new('1to2')
+
+    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!(5)
+  end
+
+  it "runs noreporting" do
+    generator = Diagram.new('1to2')
+
+    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',
+    }
+
+# I want to check the initial state
+#puts "#### Estado inicial ####"
+#puts generator
+
+# run and get the end
+    generator.run!(10)
+
+    #puts "#### Estado final ####"
+    #puts generator
+  end
+
+  it "runs sequencial" do
+    n=diagram 'test_diagram' do
+      node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8
+      node 'p2', Pool, mode: :push, activation: :automatic
+      node 'p3', Pool, mode: :push, activation: :automatic
+      node 'p4', Pool, mode: :push, activation: :automatic
+      edge 'e1', Edge, 'p1', 'p2'
+      edge 'e2', Edge, 'p2', 'p3'
+      edge 'e3', Edge, 'p3', 'p4'
+    end
+
+    n.run!(5)
+
+    #puts n
+  end
+
+  it "runs sobonito" do
+    n=diagram 'test_diagram' do
+      node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8
+      node 'p2', Pool, mode: :push, activation: :automatic
+      node 'p3', Pool, mode: :push, activation: :automatic
+      node 'p4', Pool, mode: :push, activation: :automatic
+      edge 'e1', Edge, 'p1', 'p2'
+      edge 'e2', Edge, 'p2', 'p1'
+      edge 'e3', Edge, 'p1', 'p3'
+      edge 'e4', Edge, 'p3', 'p1'
+      edge 'e5', Edge, 'p4', 'p2'
+      edge 'e6', Edge, 'p2', 'p4'
+      edge 'e7', Edge, 'p4', 'p3'
+      edge 'e8', Edge, 'p3', 'p4'
+    end
+
+    d = Diagram.new('bonitinho')
+
+    n.run!(20)
+  end
+
+  it "runs sobonitowhile" do
+    n=diagram 'test_diagram' do
+      node 'p1', Pool, mode: :push, activation: :automatic, initial_value: 8
+      node 'p2', Pool, mode: :push, activation: :automatic
+      node 'p3', Pool, mode: :push, activation: :automatic
+      node 'p4', Pool, mode: :push, activation: :automatic
+      edge 'e1', Edge, 'p1', 'p2'
+      edge 'e2', Edge, 'p2', 'p1'
+      edge 'e3', Edge, 'p1', 'p3'
+      edge 'e4', Edge, 'p3', 'p1'
+      edge 'e5', Edge, 'p4', 'p2'
+      edge 'e6', Edge, 'p2', 'p4'
+      edge 'e7', Edge, 'p4', 'p3'
+      edge 'e8', Edge, 'p3', 'p4'
+    end
+
+    d = Diagram.new('bonitinho')
+
+    n.run_while! do
+      not (n.get_node("p1").resource_count == 2 and n.get_node("p4").resource_count == 2)
+    end
+  end
+
+
+  it "runs whatIwish1" do
+
+    skip "needed features are missing"
+
+    # n=diagram 'test_diagram' do
+    #   node 'source', Source
+    #   node 'pool1', Pool
+    #   edge 'edge1', Edge, 'source', 'pool1'
+    #   node 'pool2', Pool,
+    #   converter 'c1' , Converter
+    #   node 'e3' , Edge , 'pool2' , 'c1'
+    #   trigger 't1' , Trigger , 'pool1' , 'pool2' , { |ExtendedNode p| p.resouces>0 }
+    # end
+    #
+    # n.run!(5,report=true)
+
+  end
+
+end