rbsim 0.0.3

data/spec/tcpn/add_route_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'add route'" do
+
+    let :data_token do
+      data = RBSim::Tokens::DataToken.new(34523, :node01, :sender, to: :worker1, size: 345, type: :req, content: :anything)
+      data.fragments = 1
+      data.dst_node = :node02
+      data
+    end
+
+    let :correct_route do
+      RBSim::HLModel::Route.new :node01, :node02, [ :net01, :net02 ]
+    end
+
+    let :incorrect_route1 do
+      RBSim::HLModel::Route.new :node05, :node02, [ :net04, :net03 ]
+    end
+
+    let :incorrect_route2 do
+      RBSim::HLModel::Route.new :node01, :node05, [ :net02, :net05 ]
+    end
+
+    let :routes_token do
+      routes = RBSim::Tokens::RoutesToken.new
+      routes << incorrect_route1
+      routes << correct_route
+      routes << incorrect_route2
+      routes
+    end
+
+    let :tcpn do
+      tcpn = FastTCPN.read 'tcpn/model/add_route.rb'
+
+      tcpn.add_marking_for 'data for network', data_token
+      tcpn.add_marking_for 'routes', routes_token
+      tcpn.add_marking_for 'data to receive', RBSim::Tokens::DataQueueToken.new(:worker1)
+      tcpn
+    end
+
+    it "adds correct route to data" do
+      tcpn.sim
+
+      new_data = tcpn.marking_for('data with route').first[:val]
+      expect(new_data.route.src).to eq data_token.src_node
+      expect(new_data.route.dst).to eq data_token.dst_node
+      expect(tcpn.marking_for('data to receive')).not_to be_empty
+    end
+
+  end
+end
+
+

data/spec/tcpn/cpu_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'cpu'" do
+
+    let(:node) { :node01 }
+
+    let(:times) { [ 100, 200, 300, 400 ] }
+
+    let :cpu_block do
+      i = 0
+      proc do |cpu|
+        time = times[i]
+        i += 1
+        i %= times.length
+        time
+      end
+    end
+
+    let :process_token do
+      process = RBSim::Tokens::ProcessToken.new(:test_process)
+      process.node = node
+      process.enqueue_event :cpu, block: cpu_block
+      process
+    end
+
+    let :cpu_token do
+      RBSim::Tokens::CPUToken.new(1, node)
+    end
+
+
+    let :tcpn do
+      tcpn = FastTCPN.read 'tcpn/model/cpu.rb'
+
+      tcpn.add_marking_for 'process', process_token
+      tcpn.add_marking_for 'CPU', cpu_token
+      tcpn
+    end
+
+    it "sets correct timestamps for cpu and process tokens" do
+      tcpn.sim
+
+      process_timestamp = tcpn.marking_for('process').first[:ts]
+      expect(process_timestamp).to eq times.first
+
+      cpu_timestamp = tcpn.marking_for('CPU').first[:ts]
+      expect(cpu_timestamp).to eq times.first
+    end
+
+  end
+end
+

data/spec/tcpn/map_data_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'map data'" do
+
+    let :data_token do
+      RBSim::Tokens::DataToken.new(6754, :node01, :sender, to: :worker1, size: 345, type: :req, content: :anything)
+    end
+
+    let :mapping_token do
+      { ts: 0, val: { child: :laptop, worker1: :node10, client: :old_comp } }
+    end
+
+    let :tcpn do
+      tcpn = FastTCPN.read 'tcpn/model/map_data.rb'
+
+      tcpn.add_marking_for 'data to send', data_token
+      tcpn.add_marking_for 'mapping', mapping_token
+      tcpn
+    end
+
+    it "maps data to correct node and does not touch mapping" do
+      tcpn.sim
+      data = tcpn.marking_for('data for network').first[:val]
+      expect(data.dst_node).to eq(:node10)
+
+      new_mapping = tcpn.marking_for('mapping').first[:val]
+      # check subsequent keys with values since #== is redefined!
+      mapping_token[:val].each do |k, v|
+        expect(new_mapping[k]).to eq v
+      end
+    end
+
+  end
+end
+

data/spec/tcpn/network_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'network'" do
+
+    let :route do
+      RBSim::HLModel::Route.new :node01, :node02, [ :net01, :net02, :net03 ]
+    end
+
+    let :data_token do
+      data = RBSim::Tokens::DataToken.new(6756453, :node01, :sender, to: :worker1, size: 4000, type: :req, content: :anything)
+      data.fragments = 1
+      data.dst_node = :node02
+      data.route = route
+      data
+    end
+
+    let :tcpn do
+      tcpn = FastTCPN.read 'tcpn/model/network.rb'
+
+      tcpn.add_marking_for 'data to receive', RBSim::Tokens::DataQueueToken.new(:worker1)
+      tcpn.add_marking_for 'data with route', data_token
+      bw = 50
+      [ :net01, :net02, :net03, :net04, :net05 ].each do |name|
+        tcpn.add_marking_for 'net', RBSim::Tokens::NetToken.new(name, bw)
+        bw *= 2
+      end
+
+      tcpn
+    end
+
+    it "finishes simulation with correct clock value" do
+      tcpn.sim
+      time = 7.0*data_token.size/200
+      expect(tcpn.clock).to eq time
+    end
+
+    it "finishes simulation with data token in 'data to receive' place" do
+      tcpn.sim
+      expect(tcpn.marking_for('data to receive').first[:val].get).to eq data_token
+    end
+
+    it "fires net transition correct number of times" do
+      count = 0
+      tcpn.cb_for :transition, :before do |t, e|
+        if e.transition == 'net'
+          d = e.binding['data with route'].value
+          count += 1
+        end
+      end
+      tcpn.sim
+
+      expect(count).to eq(route.via.length)
+
+    end
+
+    it "correctly updates timestamps of net tokens" do
+      tcpn.sim
+      time = 0
+      [:net01, :net02, :net03].each do |net_name|
+        net = tcpn.marking_for('net').select { |net| net[:val].name == net_name }.first
+        expect(net[:ts]).to eq(data_token.size/net[:val].bw + time)
+        time = net[:ts]
+      end
+    end
+
+    describe "for fragmented data" do
+      let :data_token do
+        data = RBSim::Tokens::DataToken.new(6756453, :node01, :sender, to: :worker1, size: 4000, type: :req, content: :anything)
+        data.fragments = 10
+        data.dst_node = :node02
+        data.route = route
+        data
+      end
+
+      it "correctly updates timestamps of net tokens respecting number of fragments" do
+        tcpn.sim
+        time = 0
+        [:net01, :net02, :net03].each do |net_name|
+          net = tcpn.marking_for('net').select { |net| net[:val].name == net_name }.first
+          expect(net[:ts]).to eq(data_token.size/net[:val].bw/data_token.fragments + time)
+          time = net[:ts]
+        end
+      end
+    end
+
+    describe "dropping packages" do
+
+      let :route do
+        RBSim::HLModel::Route.new :node01, :node02, [ :net01 ]
+      end
+
+      let :data_token do
+        data = RBSim::Tokens::DataToken.new(354232, :node01, :sender, to: :worker1, size: 4000, type: :req, content: :anything)
+        data.fragments = 1
+        data.dst_node = :node02
+        data.route = route
+        data
+      end
+
+      let :tcpn do
+        tcpn = FastTCPN.read 'tcpn/model/network.rb'
+
+        tcpn.add_marking_for 'data to receive', RBSim::Tokens::DataQueueToken.new(:worker1)
+        tcpn.add_marking_for 'data with route', data_token
+        tcpn.add_marking_for 'net', RBSim::Tokens::NetToken.new(:net01, 50, 0, drop)
+        tcpn
+      end
+
+      describe "when #drop? returns false" do
+        let(:drop) { ->{ false } }
+
+        it "does not drop package" do
+          tcpn.sim
+          expect(tcpn.marking_for('data to receive').first[:val].get).to eq data_token
+        end
+      end
+
+      describe "when #drop? returns true" do
+        let(:drop) { ->{ true } }
+
+        it "drops package" do
+          tcpn.sim
+          expect(tcpn.marking_for('data to receive').first[:val]).to be_empty
+        end
+      end
+
+      describe "when #drop? returns false then true" do
+        let :data_token do
+          data1 = RBSim::Tokens::DataToken.new(6755, :node01, :sender, to: :worker1, size: 4000, type: :req, content: :anything)
+          data1.fragments = 1
+          data1.dst_node = :node02
+          data1.route = route
+
+          data2 = RBSim::Tokens::DataToken.new(9876, :node01, :sender, to: :worker1, size: 4000, type: :req, content: :anything)
+          data2.fragments = 1
+          data2.dst_node = :node02
+          data2.route = route
+
+          [ data1, data2 ]
+        end
+
+        let(:drop) do 
+          values = [ false, true ]
+          lambda do
+            values.shift
+          end
+        end
+
+        it "drops one package and lets one package go" do
+          tcpn.sim
+          expect(tcpn.marking_for('data to receive').first[:val].length).to be 1
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/spec/tcpn/register_event_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'register event'" do
+
+    let :process_token do
+      process = RBSim::Tokens::ProcessToken.new(:test_process)
+      process.node = :node01
+      process.enqueue_event :register_event, { event: :data, delay: 10, event_args: 1024 }
+      process.on_event :data do
+      end
+      process
+    end
+
+    let :tcpn do
+      tcpn = FastTCPN.read 'tcpn/model/register_event.rb'
+
+      tcpn.add_marking_for 'process', process_token
+      tcpn
+    end
+
+    it "enqueues event in specified time" do
+      register_event_fired = false
+      enqueue_event_fired = false
+      tcpn.cb_for :transition, :after do |t, e|
+        if e.transition == 'event::register_event'
+          register_event_fired = true
+        elsif e.transition == 'event::enqueue_event'
+          enqueue_event_fired = true
+        end
+      end
+
+      tcpn.sim
+
+      expect(register_event_fired).to be true
+      expect(enqueue_event_fired).to be true
+
+      process_timestamp = tcpn.marking_for('process').first[:ts]
+      expect(process_timestamp).to eq(10)
+
+      process = tcpn.marking_for('process').first[:val]
+      expect(process.has_event? :data).to be true
+    end
+
+   end
+end
+

data/spec/tcpn/route_to_self_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'add route'" do
+
+    context "route from node to self" do
+      let :data_token do
+        data = RBSim::Tokens::DataToken.new(6756454, :node01, :sender, to: :worker1, size: 345, type: :req, content: :anything)
+        data.fragments = 1
+        data.dst_node = :node01
+        data
+      end
+
+
+      let :incorrect_route1 do
+        RBSim::HLModel::Route.new :node05, :node02, [ :net04, :net03 ]
+      end
+
+      let :incorrect_route2 do
+        RBSim::HLModel::Route.new :node01, :node05, [ :net02, :net05 ]
+      end
+
+      let :routes_token do
+        routes = RBSim::Tokens::RoutesToken.new
+        routes << incorrect_route1
+        routes << incorrect_route2
+        routes
+      end
+
+      let :tcpn do
+        tcpn = FastTCPN.read 'tcpn/model/add_route.rb'
+
+        tcpn.add_marking_for 'data for network', data_token
+        tcpn.add_marking_for 'routes', routes_token
+        tcpn.add_marking_for 'data to receive', RBSim::Tokens::DataQueueToken.new(:worker1)
+        tcpn
+      end
+
+      it "adds correct route to data" do
+        tcpn.sim
+
+        expect(tcpn.marking_for('data with route')).to eq([])
+        expect(tcpn.marking_for('data to receive').first[:val].get).to eq(data_token)
+      end
+
+    end
+
+  end
+end
+
+
+

data/spec/tcpn/stats_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe "TCPN model" do
+
+  describe "page 'stats'" do
+
+    let :process_token do
+      process = RBSim::Tokens::ProcessToken.new(:test_process)
+      process.node = :node01
+      process.enqueue_event stats_event, event_params
+      process
+    end
+
+    let(:event_params) { { tag: stats_tag, group_name: stats_group_name } }
+
+    let :tcpn do
+      tcpn = FastTCPN.read 'tcpn/model/stats.rb'
+
+      tcpn.add_marking_for 'process', process_token
+      tcpn
+    end
+
+    let(:stats_group_name) { 'apache' }
+
+    shared_examples "is served" do
+      it "is served" do
+        served = false
+        args = nil
+        tcpn.cb_for :transition, :after do |t, e|
+          if e.transition == 'event::stats'
+            served = true if e.binding['process'].value.has_event?(stats_event)
+            args = e.binding['process'].value.serve_system_event(stats_event)[:args]
+          end
+        end
+
+        tcpn.sim
+
+        expect(served).to be true
+        expect(args).to eql(event_params)
+      end
+    end
+
+    describe ":stats event" do
+      let(:stats_event) { :stats }
+      let(:stats_tag) { :work }
+
+      include_examples 'is served'
+    end
+
+    describe ":stats_start event" do
+      let(:stats_event) { :stats_start }
+      let(:stats_tag) { :doing }
+
+      include_examples 'is served'
+    end
+
+    describe ":stats_stop event" do
+      let(:stats_event) { :stats_stop }
+      let(:stats_tag) { :doing }
+
+      include_examples 'is served'
+    end
+
+    describe ":stats_save event" do
+      let(:stats_event) { :stats_save }
+      let(:stats_tag) { :doing }
+      let(:event_value) { 2345 }
+      let(:event_params) { { value: event_value, tag: stats_tag, group_name: stats_group_name } }
+
+      include_examples 'is served'
+    end
+
+  end
+end
+
+
+