arborist 0.0.1.pre20160128152542 → 0.0.1.pre20160606141735

data/spec/arborist/event/node_spec.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../spec_helper'
+
+require 'arborist/node'
+require 'arborist/subscription'
+require 'arborist/event/node'
+
+
+describe Arborist::Event::Node do
+
+	let( :node ) do
+		TestNode.new( 'foo' ) do
+			parent 'bar'
+			description "A testing node"
+			tags :yelp, :yank, :yore, :yandex
+
+			update(
+				"tcp_socket_connect" => {
+					"time" => "2016-02-25 16:04:35 -0800",
+					"duration" => 0.020619
+				}
+			)
+		end
+	end
+	let( :event ) { described_class.new(node) }
+
+
+
+	it "matches match-anything subscriptions" do
+		sub = Arborist::Subscription.new {}
+		expect( event ).to match( sub )
+	end
+
+
+	it "matches subscriptions which have matching criteria" do
+		criteria = {
+			tag: node.tags.last,
+			status: node.status
+		}
+		sub = Arborist::Subscription.new( nil, criteria ) {}
+
+		expect( event ).to match( sub )
+	end
+
+
+	it "matches subscriptions which have non-matching negative criteria" do
+		pending "Adding negative criteria to subscriptions"
+		negative_criteria = {
+			tag: 'nope'
+		}
+		sub = Arborist::Subscription.new( nil, {}, negative_criteria ) {}
+
+		expect( event ).to match( sub )
+	end
+
+
+end
+

data/spec/arborist/event/node_update_spec.rb

@@ -41,7 +41,7 @@ describe Arborist::Event::NodeUpdate do
 	describe "subscription support" do
 
 		it "matches a subscription with only an event type if the type is the same" do
-			sub = Arborist::Subscription.new( :publisher, 'node.update' )
+			sub = Arborist::Subscription.new( 'node.update' ) {}
 			event = described_class.new( node )
 
 			expect( event ).to match( sub )
@@ -49,7 +49,7 @@ describe Arborist::Event::NodeUpdate do
 
 
 		it "matches a subscription with a matching event type and matching criteria" do
-			sub = Arborist::Subscription.new( :publisher, 'node.update', 'tag' => 'chunker' )
+			sub = Arborist::Subscription.new( 'node.update', 'tag' => 'chunker' ) {}
 			event = described_class.new( node )
 
 			expect( event ).to match( sub )
@@ -57,7 +57,7 @@ describe Arborist::Event::NodeUpdate do
 
 
 		it "doesn't match a subscription with a matching event type if the criteria don't match" do
-			sub = Arborist::Subscription.new( :publisher, 'node.update', 'tag' => 'looper' )
+			sub = Arborist::Subscription.new( 'node.update', 'tag' => 'looper' ) {}
 			event = described_class.new( node )
 
 			expect( event ).to_not match( sub )
@@ -67,5 +67,16 @@ describe Arborist::Event::NodeUpdate do
 	end
 
 
+	describe "payload" do
+
+		it "includes its attributes" do
+			event = described_class.new( node )
+
+			expect( event.payload ).to be_a( Hash )
+			expect( event.payload ).to include( :status, :properties, :type )
+		end
+
+	end
+
 end
 

data/spec/arborist/event_spec.rb

@@ -26,7 +26,7 @@ describe Arborist::Event do
 	describe "subscription support" do
 
 		it "matches a subscription with only an event type if the type is the same" do
-			sub = Arborist::Subscription.new( :publisher, 'test.event' )
+			sub = Arborist::Subscription.new( 'test.event' ) {}
 			event = described_class.create( TestEvent, [] )
 
 			expect( event ).to match( sub )
@@ -34,7 +34,7 @@ describe Arborist::Event do
 
 
 		it "always matches a subscription with a nil event type" do
-			sub = Arborist::Subscription.new( :publisher )
+			sub = Arborist::Subscription.new {}
 			event = described_class.create( TestEvent, [] )
 
 			expect( event ).to match( sub )
@@ -49,7 +49,7 @@ describe Arborist::Event do
 			payload = { 'status' => ['up', 'down'] }
 			ev = TestEvent.create( TestEvent, payload )
 
-			result = ev.to_hash
+			result = ev.to_h
 
 			expect( result ).to include( 'type', 'data' )
 

data/spec/arborist/manager/tree_api_spec.rb

@@ -122,14 +122,14 @@ describe Arborist::Manager::TreeAPI, :testing_manager do
 		end
 
 
-		it "send an error response if the request's body is not a Map or Nil" do
+		it "send an error response if the request's body is not Nil, a Map, or an Array of Maps" do
 			sock.send( MessagePack.pack([{version: 1, action: 'list'}, 18]) )
 			resmsg = sock.recv
 
 			hdr, body = unpack_message( resmsg )
 			expect( hdr ).to include(
 				'success'  => false,
-				'reason'   => /invalid request.*body must be a map or nil/i,
+				'reason'   => /invalid request.*body must be nil, a map, or an array of maps/i,
 				'category' => 'client'
 			)
 			expect( body ).to be_nil
@@ -217,6 +217,40 @@ describe Arborist::Manager::TreeAPI, :testing_manager do
 		end
 
 
+		it "returns an array of full state maps for nodes not matching specified negative criteria" do
+			msg = pack_message( :fetch, [ {}, {type: 'service', port: 22} ] )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+
+			expect( body ).to be_a( Hash )
+			expect( body.length ).to eq( manager.nodes.length - 3 )
+
+			expect( body.values ).to all( be_a(Hash) )
+			expect( body.values ).to all( include('status', 'type') )
+		end
+
+
+		it "returns an array of full state maps for nodes combining positive and negative criteria" do
+			msg = pack_message( :fetch, [ {type: 'service'}, {port: 22} ] )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+
+			expect( body ).to be_a( Hash )
+			expect( body.length ).to eq( 16 )
+
+			expect( body.values ).to all( be_a(Hash) )
+			expect( body.values ).to all( include('status', 'type') )
+		end
+
+
 		it "doesn't return nodes beneath downed nodes by default" do
 			manager.nodes['sidonie'].update( error: 'sunspots' )
 			msg = pack_message( :fetch, type: 'service', port: 22 )
@@ -276,6 +310,7 @@ describe Arborist::Manager::TreeAPI, :testing_manager do
 			expect( body.values.map(&:keys) ).to all( contain_exactly('status', 'tags', 'addresses') )
 		end
 
+
 	end
 
 
@@ -292,11 +327,25 @@ describe Arborist::Manager::TreeAPI, :testing_manager do
 			expect( body ).to all( be_a(Hash) )
 			expect( body ).to include( hash_including('identifier' => '_') )
 			expect( body ).to include( hash_including('identifier' => 'duir') )
+			expect( body ).to include( hash_including('identifier' => 'sidonie') )
 			expect( body ).to include( hash_including('identifier' => 'sidonie-ssh') )
 			expect( body ).to include( hash_including('identifier' => 'sidonie-demon-http') )
 			expect( body ).to include( hash_including('identifier' => 'yevaud') )
 		end
 
+		it "can be limited by depth" do
+			msg = pack_message( :list, {depth: 1}, nil )
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body.length ).to eq( 3 )
+			expect( body ).to all( be_a(Hash) )
+			expect( body ).to include( hash_including('identifier' => '_') )
+			expect( body ).to include( hash_including('identifier' => 'duir') )
+			expect( body ).to_not include( hash_including('identifier' => 'duir-ssh') )
+		end
 	end
 
 
@@ -456,4 +505,247 @@ describe Arborist::Manager::TreeAPI, :testing_manager do
 
 	end
 
-end
+
+	describe "prune" do
+
+		it "removes a single node" do
+			msg = pack_message( :prune, {identifier: 'duir-ssh'}, nil )
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body ).to eq( true )
+			expect( manager.nodes ).to_not include( 'duir-ssh' )
+		end
+
+
+		it "returns Nil without error if the node to prune didn't exist" do
+			msg = pack_message( :prune, {identifier: 'shemp-ssh'}, nil )
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body ).to be_nil
+		end
+
+
+		it "removes children nodes along with the parent" do
+			msg = pack_message( :prune, {identifier: 'duir'}, nil )
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body ).to eq( true )
+			expect( manager.nodes ).to_not include( 'duir' )
+			expect( manager.nodes ).to_not include( 'duir-ssh' )
+		end
+
+
+		it "returns an error to the client when missing required attributes" do
+			msg = pack_message( :prune )
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => false )
+			expect( hdr['reason'] ).to match( /no identifier/i )
+		end
+	end
+
+
+	describe "graft" do
+
+		it "can add a node with no explicit parent" do
+			header = {
+				identifier: 'guenter',
+		        type: 'host',
+			}
+			attributes = {
+				description: 'The evil penguin node of doom.',
+				addresses: ['10.2.66.8'],
+				tags: ['internal', 'football']
+			}
+			msg = pack_message( :graft, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body ).to eq( 'guenter' )
+
+			new_node = manager.nodes[ 'guenter' ]
+			expect( new_node ).to be_a( Arborist::Node::Host )
+			expect( new_node.identifier ).to eq( header[:identifier] )
+			expect( new_node.description ).to eq( attributes[:description] )
+			expect( new_node.addresses ).to eq([ IPAddr.new(attributes[:addresses].first) ])
+			expect( new_node.tags ).to include( *attributes[:tags] )
+		end
+
+
+		it "can add a node with a parent specified" do
+			header = {
+				identifier: 'orgalorg',
+		        type: 'host',
+				parent: 'duir'
+			}
+			attributes = {
+				description: 'The true form of the evil penguin node of doom.',
+				addresses: ['192.168.22.8'],
+				tags: ['evil', 'space', 'entity']
+			}
+			msg = pack_message( :graft, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body ).to eq( 'orgalorg' )
+
+			new_node = manager.nodes[ 'orgalorg' ]
+			expect( new_node ).to be_a( Arborist::Node::Host )
+			expect( new_node.identifier ).to eq( header[:identifier] )
+			expect( new_node.parent ).to eq( header[:parent] )
+			expect( new_node.description ).to eq( attributes[:description] )
+			expect( new_node.addresses ).to eq([ IPAddr.new(attributes[:addresses].first) ])
+			expect( new_node.tags ).to include( *attributes[:tags] )
+		end
+
+
+		it "can add a subordinate node" do
+			header = {
+				identifier: 'echo',
+		        type: 'service',
+				parent: 'duir'
+			}
+			attributes = {
+				description: 'Mmmmm AppleTalk.'
+			}
+			msg = pack_message( :graft, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+			expect( body ).to eq( 'duir-echo' )
+
+			new_node = manager.nodes[ 'duir-echo' ]
+			expect( new_node ).to be_a( Arborist::Node::Service )
+			expect( new_node.identifier ).to eq( 'duir-echo' )
+			expect( new_node.parent ).to eq( header[:parent] )
+			expect( new_node.description ).to eq( attributes[:description] )
+			expect( new_node.port ).to eq( 7 )
+			expect( new_node.protocol ).to eq( 'tcp' )
+			expect( new_node.app_protocol ).to eq( 'echo' )
+		end
+
+
+		it "errors if adding a subordinate node with no parent" do
+			header = {
+				identifier: 'echo',
+		        type: 'service'
+			}
+			attributes = {
+				description: 'Mmmmm AppleTalk.'
+			}
+			msg = pack_message( :graft, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => false )
+			expect( hdr['reason'] ).to match( /no host given/i )
+		end
+
+	end
+
+
+	describe "modify" do
+
+		it "can change operational attributes of a node" do
+			header = {
+				identifier: 'sidonie',
+			}
+			attributes = {
+				parent: '_',
+				addresses: ['192.168.32.32', '10.2.2.28']
+			}
+			msg = pack_message( :modify, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+
+			node = manager.nodes[ 'sidonie' ]
+			expect(
+				node.addresses
+			).to eq( [IPAddr.new('192.168.32.32'), IPAddr.new('10.2.2.28')] )
+			expect( node.parent ).to eq( '_' )
+		end
+
+
+		it "ignores modifications to unsupported attributes" do
+			header = {
+				identifier: 'sidonie',
+			}
+			attributes = {
+				identifier: 'somethingelse'
+			}
+			msg = pack_message( :modify, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => true )
+
+			expect( manager.nodes['sidonie'] ).to be_an( Arborist::Node )
+			expect( manager.nodes['sidonie'].identifier ).to eq( 'sidonie' )
+		end
+
+
+		it "errors on modifications to the root node" do
+			header = {
+				identifier: '_',
+			}
+			attributes = {
+				identifier: 'somethingelse'
+			}
+			msg = pack_message( :modify, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => false )
+			expect( manager.nodes['_'].identifier ).to eq( '_' )
+		end
+
+
+		it "errors on modifications to nonexistent nodes" do
+			header = {
+				identifier: 'nopenopenope',
+			}
+			attributes = {
+				identifier: 'somethingelse'
+			}
+			msg = pack_message( :modify, header, attributes )
+
+			sock.send( msg )
+			resmsg = sock.recv
+
+			hdr, body = unpack_message( resmsg )
+			expect( hdr ).to include( 'success' => false )
+		end
+	end
+
+end
+