arborist 0.0.1.pre20160128152542 → 0.0.1.pre20160606141735

data/spec/arborist/node/ack_spec.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../spec_helper'
+require 'arborist/node/ack'
+
+
+describe Arborist::Node::Ack do
+
+	it "can be constructed with a sender and a message" do
+		result = described_class.new( "a message", "a sender" )
+		expect( result ).to be_a( described_class )
+		expect( result.message ).to eq( "a message" )
+		expect( result.sender ).to eq( "a sender" )
+
+		expect( result.time ).to be_within( 2 ).of( Time.now )
+		expect( result.via ).to be_nil
+	end
+
+
+	it "requires a sender" do
+		expect {
+			described_class.from_hash( message: 'hi!' )
+		}.to raise_error( ArgumentError, /missing required ack sender/i )
+	end
+
+	it "requires a message" do
+		expect {
+			described_class.from_hash( sender: 'slick rick' )
+		}.to raise_error( ArgumentError, /missing required ack message/i )
+	end
+
+	it "can be round-tripped to a Hash and back" do
+		result = described_class.new( 'boom', 'explosivo' )
+		expect( described_class.from_hash(result.to_h) ).to eq( result )
+	end
+
+
+	it "can describe itself" do
+		ack = described_class.new( "someone else's problem", "Hike Mix" )
+		expect( ack.description ).to match( /by hike mix -- someone else's problem/i )
+	end
+
+	it "can describe itself with a via source" do
+		ack = described_class.new( "someone else's problem", "Hike Mix", via: "sms" )
+		expect( ack.description ).to match( /by hike mix via sms -- someone else's problem/i )
+	end
+
+
+	describe "time argument" do
+
+		it "can be constructed with a Time" do
+			result = described_class.
+				from_hash( message: 'message', sender: 'sender', time: Time.at(1460569977) )
+			expect( result.time.to_i ).to eq( 1460569977 )
+		end
+
+
+		it "can be constructed with a numeric time" do
+			result = described_class.
+				from_hash( message: 'message', sender: 'sender', time: 1460569977 )
+			expect( result.time.to_i ).to eq( 1460569977 )
+		end
+
+
+		it "can be constructed with a string time" do
+			result = described_class.
+				from_hash( message: 'message', sender: 'sender', time: Time.at(1460569977).iso8601 )
+			expect( result.time.to_i ).to eq( 1460569977 )
+		end
+
+	end
+
+end
+

data/spec/arborist/node/host_spec.rb

@@ -75,6 +75,85 @@ describe Arborist::Node::Host do
 	end
 
 
+	it "can be created with address attributes" do
+		result = described_class.new( 'testhost', addresses: '192.168.118.3' )
+		expect( result.addresses ).to include( IPAddr.new('192.168.118.3') )
+	end
+
+
+	it "appends block address arguments to addresses in attributes" do
+		result = described_class.new( 'testhost', addresses: '192.168.118.3' ) do
+			address '127.0.0.1'
+		end
+
+		expect( result.addresses.length ).to eq( 2 )
+		expect( result.addresses ).to include(
+			IPAddr.new( '192.168.118.3' ),
+			IPAddr.new( '127.0.0.1' )
+		)
+	end
+
+
+	it "replaces its addresses when it's updated via #modify" do
+		result = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+		end
+
+		result.modify( addresses: ['192.168.28.2'] )
+
+		expect( result.addresses ).to include( IPAddr.new('192.168.28.2') )
+		expect( result.addresses ).to_not include( IPAddr.new('192.168.118.3') )
+	end
+
+
+	it "includes its addresses when turned into a Hash" do
+		node = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+		end
+
+		expect( node.to_h ).to include( :addresses )
+		expect( node.to_h[:addresses] ).to eq([ '192.168.118.3' ])
+	end
+
+
+	it "keeps its addresses when marshalled" do
+		node = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+			address '192.168.67.2'
+		end
+		clone = Marshal.load( Marshal.dump(node) )
+
+		expect( clone.addresses ).to eq( node.addresses )
+	end
+
+
+	it "is equal to another host node with the same metadata and addresses" do
+		node1 = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+			address '192.168.67.2'
+		end
+		node2 = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+			address '192.168.67.2'
+		end
+
+		expect( node1 ).to eq( node2 )
+	end
+
+
+	it "is not equal to another host node with the same metadata and different addresses" do
+		node1 = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+			address '192.168.67.2'
+		end
+		node2 = described_class.new( 'testhost' ) do
+			address '192.168.118.3'
+		end
+
+		expect( node1 ).to_not eq( node2 )
+	end
+
+
 	describe "matching" do
 
 		let( :node ) do

data/spec/arborist/node/resource_spec.rb

@@ -0,0 +1,56 @@
+#!/usr/bin/env rspec -cfd
+
+require_relative '../../spec_helper'
+
+require 'arborist/node/resource'
+
+
+describe Arborist::Node::Resource do
+
+	let( :host ) do
+		Arborist::Node.create( 'host', 'testhost' ) do
+			address '192.168.118.3'
+		end
+	end
+
+
+	it "can be created without reasonable defaults based on its identifier" do
+		result = described_class.new( 'disk', host )
+		expect( result.identifier ).to eq( "testhost-disk" )
+	end
+
+
+	it "raises a sensible error when created without a host" do
+		expect {
+			described_class.new( 'load', nil )
+		}.to raise_error( Arborist::NodeError, /no host/i )
+	end
+
+	describe "matching" do
+
+		let( :host ) do
+			Arborist::Node.create( 'host', 'testhost' ) do
+				address '192.168.66.12'
+				address '10.1.33.8'
+			end
+		end
+
+		let( :node ) do
+			described_class.new( 'disk', host )
+		end
+
+
+		it "can be matched with one of its host's addresses" do
+			expect( node ).to match_criteria( address: '192.168.66.12' )
+			expect( node ).to_not match_criteria( address: '127.0.0.1' )
+		end
+
+		it "can be matched with a netblock that includes one of its host's addresses" do
+			expect( node ).to match_criteria( address: '192.168.66.0/24' )
+			expect( node ).to match_criteria( address: '10.0.0.0/8' )
+			expect( node ).to_not match_criteria( address: '192.168.66.64/27' )
+			expect( node ).to_not match_criteria( address: '127.0.0.0/8' )
+		end
+	end
+end
+

data/spec/arborist/node/service_spec.rb

@@ -9,8 +9,7 @@ describe Arborist::Node::Service do
 
 	let( :host ) do
 		Arborist::Node.create( 'host', 'testhost' ) do
-			address '192.168.66.12'
-			address '10.2.12.68'
+			address '192.168.118.3'
 		end
 	end
 
@@ -49,8 +48,75 @@ describe Arborist::Node::Service do
 	end
 
 
+	it "raises a sensible error when created without a host" do
+		expect {
+			described_class.new( 'dnsd', nil )
+		}.to raise_error( Arborist::NodeError, /no host/i )
+	end
+
+
+	it "includes its service attributes when turned into a Hash" do
+		service = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+
+		expect( service.to_h ).to include( :port, :protocol, :app_protocol )
+		expect( service.to_h[:port] ).to eq( service.port )
+		expect( service.to_h[:protocol] ).to eq( service.protocol )
+		expect( service.to_h[:app_protocol] ).to eq( service.app_protocol )
+	end
+
+
+	it "keeps its service attributes when marshalled" do
+		service = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+
+		expect( service.to_h ).to include( :port, :protocol, :app_protocol )
+		expect( service.to_h[:port] ).to eq( service.port )
+		expect( service.to_h[:protocol] ).to eq( service.protocol )
+		expect( service.to_h[:app_protocol] ).to eq( service.app_protocol )
+	end
+
+
+	it "is equal to another service node with the same metadata and service attributes" do
+		service1 = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+		service2 = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+
+		expect( service1 ).to eq( service2 )
+	end
+
+
+	it "is not equal to another service node with the same metadata and different service attributes" do
+		service1 = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+		service2 = described_class.new( 'dnsd', host, port: 53, protocol: 'tcp', app_protocol: 'dns' )
+
+		expect( service1 ).to_not eq( service2 )
+	end
+
+
+	it "is not equal to another service node with the same metadata and different port" do
+		service1 = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+		service2 = described_class.new( 'dnsd', host, port: 80, protocol: 'udp', app_protocol: 'dns' )
+
+		expect( service1 ).to_not eq( service2 )
+	end
+
+
+	it "is not equal to another service node with the same metadata and different app protocol" do
+		service1 = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'dns' )
+		service2 = described_class.new( 'dnsd', host, port: 53, protocol: 'udp', app_protocol: 'smtp' )
+
+		expect( service1 ).to_not eq( service2 )
+	end
+
+
+
 	describe "matching" do
 
+		let( :host ) do
+			Arborist::Node.create( 'host', 'testhost' ) do
+				address '192.168.66.12'
+				address '10.1.33.8'
+			end
+		end
+
 		let( :node ) do
 			described_class.new( 'ssh', host )
 		end

data/spec/arborist/node_spec.rb

@@ -9,10 +9,12 @@ require 'arborist/node'
 describe Arborist::Node do
 
 	let( :concrete_class ) { TestNode }
+	let( :subnode_class ) { TestSubNode }
 
 	let( :identifier ) { 'the_identifier' }
 	let( :identifier2 ) { 'the_other_identifier' }
 
+
 	it "can be loaded from a file" do
 		concrete_instance = nil
 		expect( Kernel ).to receive( :load ).with( "a/path/to/a/node.rb" ) do
@@ -26,6 +28,20 @@ describe Arborist::Node do
 	end
 
 
+	it "can be constructed from a Hash" do
+		instance = concrete_class.new( identifier,
+			parent: 'branch',
+			description: 'A testing node',
+			tags: ['internal', 'testing']
+		)
+
+		expect( instance ).to be_a( described_class )
+		expect( instance.parent ).to eq( 'branch' )
+		expect( instance.description ).to eq( 'A testing node' )
+		expect( instance.tags ).to include( 'internal', 'testing' )
+	end
+
+
 	it "can load multiple nodes from a single file" do
 		concrete_instance1 = concrete_instance2 = nil
 		expect( Kernel ).to receive( :load ).with( "a/path/to/a/node.rb" ) do
@@ -57,6 +73,23 @@ describe Arborist::Node do
 	end
 
 
+	context "subnode classes" do
+
+		it "can declare the type of node they live under" do
+			expect( subnode_class.parent_types ).to include( described_class.get_subclass(:test) )
+		end
+
+
+		it "can be constructed via a factory method on instances of their parent type" do
+			parent = concrete_class.new( 'branch' )
+			node = parent.testsub( 'leaf' )
+			expect( node ).to be_an_instance_of( subnode_class )
+			expect( node.parent ).to eq( parent.identifier )
+		end
+
+	end
+
+
 	context "an instance of a concrete subclass" do
 
 		let( :node ) { concrete_class.new(identifier) }
@@ -145,6 +178,26 @@ describe Arborist::Node do
 				expect( node ).to be_acked
 			end
 
+			it "transitions from `acked` to `up` status if its error is cleared" do
+				node.status = 'down'
+				node.error = 'Something is wrong | he falls | betraying the trust | "\
+					"there is a disaster in his life.'
+				node.update( ack: {message: "Leitmotiv", sender: 'ged'}  )
+				node.update( error: nil )
+
+				expect( node ).to be_up
+			end
+
+			it "stays `up` if its error is cleared and stays cleared" do
+				node.status = 'down'
+				node.error = 'stay up damn you!'
+				node.update( ack: {message: "Leitmotiv", sender: 'ged'}  )
+				node.update( error: nil )
+				node.update( error: nil )
+
+				expect( node ).to be_up
+			end
+
 			it "transitions to `disabled` from `up` status if it's updated with an `ack` property" do
 				node.status = 'up'
 				node.update( ack: {message: "Maintenance", sender: 'mahlon'} )
@@ -298,19 +351,96 @@ describe Arborist::Node do
 					description "The prototypical node"
 					tags :chunker, :hunky, :flippin, :hippo
 
+					depends_on(
+						all_of('postgres', 'rabbitmq', 'memcached', on: 'svchost'),
+						any_of('webproxy', on: ['fe-host1','fe-host2','fe-host3'])
+					)
+
 					update( 'song' => 'Around the World', 'artist' => 'Daft Punk', 'length' => '7:09' )
 				end
 			end
 
 
+			it "can restore saved state from an older copy of the node" do
+				old_node = Marshal.load( Marshal.dump(node) )
+
+				old_node.status = 'down'
+				old_node.status_changed = Time.now - 400
+				old_node.error = "Host unreachable"
+				old_node.update(
+					ack: {
+						'time' => Time.now - 200,
+						'message' => "Technician dispatched.",
+						'sender' => 'darby@example.com'
+					}
+				)
+				old_node.properties.replace(
+					'ping' => {
+						'ttl' => 0.23
+					}
+				)
+				old_node.last_contacted = Time.now - 28
+				old_node.dependencies.mark_down( 'svchost-postgres' )
+
+				node.restore( old_node )
+
+				expect( node.status ).to eq( old_node.status )
+				expect( node.status_changed ).to eq( old_node.status_changed )
+				expect( node.error ).to eq( old_node.error )
+				expect( node.ack ).to eq( old_node.ack )
+				expect( node.properties ).to include( old_node.properties )
+				expect( node.last_contacted ).to eq( old_node.last_contacted )
+				expect( node.dependencies ).to eql( old_node.dependencies )
+			end
+
+
+			it "doesn't restore operational attributes from the node file on disk with those from saved state" do
+				old_node = Marshal.load( Marshal.dump(node) )
+				node_copy = Marshal.load( Marshal.dump(node) )
+
+				old_node.instance_variable_set( :@parent, 'foo' )
+				old_node.instance_variable_set( :@description, 'Some older description' )
+				old_node.tags( :bunker, :lucky, :tickle, :trucker )
+				old_node.source = '/somewhere/else'
+
+				node.restore( old_node )
+
+				expect( node.parent ).to eq( node_copy.parent )
+				expect( node.description ).to eq( node_copy.description )
+				expect( node.tags ).to eq( node_copy.tags )
+				expect( node.source ).to eq( node_copy.source )
+				expect( node.dependencies ).to eq( node_copy.dependencies )
+			end
+
+
+			it "doesn't replace dependencies if they've changed" do
+				old_node = Marshal.load( Marshal.dump(node) )
+				old_node.dependencies.mark_down( 'svchost-postgres' )
+				old_node.dependencies.mark_down( 'svchost-rabbitmq' )
+
+				# Drop 'svchost-rabbitmq'
+				node.depends_on(
+					node.all_of('postgres', 'memcached', on: 'svchost'),
+					node.any_of('webproxy', on: ['fe-host1','fe-host2','fe-host3'])
+				)
+
+				node.restore( old_node )
+
+				expect( node.dependencies ).to_not eql( old_node.dependencies )
+				expect( node.dependencies.all_identifiers ).to_not include( 'svchost-rabbitmq' )
+				expect( node.dependencies.down_subdeps.length ).to eq( 1 )
+			end
+
+
 			it "can return a Hash of serializable node data" do
-				result = node.to_hash
+				result = node.to_h
 
 				expect( result ).to be_a( Hash )
 				expect( result ).to include(
 					:identifier,
-					:parent, :description, :tags, :properties, :status, :ack,
-					:last_contacted, :status_changed, :error
+					:parent, :description, :tags, :properties, :ack, :status,
+					:last_contacted, :status_changed, :error, :quieted_reasons,
+					:dependencies
 				)
 				expect( result[:identifier] ).to eq( 'foo' )
 				expect( result[:type] ).to eq( 'testnode' )
@@ -318,29 +448,33 @@ describe Arborist::Node do
 				expect( result[:description] ).to eq( node.description )
 				expect( result[:tags] ).to eq( node.tags )
 				expect( result[:properties] ).to eq( node.properties )
-				expect( result[:status] ).to eq( node.status )
 				expect( result[:ack] ).to be_nil
 				expect( result[:last_contacted] ).to eq( node.last_contacted.iso8601 )
 				expect( result[:status_changed] ).to eq( node.status_changed.iso8601 )
 				expect( result[:error] ).to be_nil
+				expect( result[:dependencies] ).to be_a( Hash )
+				expect( result[:quieted_reasons] ).to be_a( Hash )
 			end
 
 
 			it "can be reconstituted from a serialized Hash of node data" do
-				hash = node.to_hash
+				hash = node.to_h
 				cloned_node = concrete_class.from_hash( hash )
 
 				expect( cloned_node ).to eq( node )
 			end
 
 
-			it "an ACKed node stays ACKed when reconstituted" do
+			it "an ACKed node goes back to ACKed when re-added to the tree" do
+
 				node.update( error: "there's a fire" )
 				node.update( ack: {
 					message: 'We know about the fire. It rages on.',
 					sender: '1986 Labyrinth David Bowie'
 				})
-				cloned_node = concrete_class.from_hash( node.to_hash )
+				cloned_node = concrete_class.from_hash( node.to_h )
+				node_added_event = Arborist::Event.create( :sys_node_added, cloned_node )
+				cloned_node.handle_event( node_added_event )
 
 				expect( cloned_node ).to be_acked
 			end
@@ -448,7 +582,7 @@ describe Arborist::Node do
 			ack_event = events.find {|ev| ev.type == 'node.acked' }
 
 			expect( ack_event ).to be_a( Arborist::Event )
-			expect( ack_event.payload ).to include( sender: 'Seabound' )
+			expect( ack_event.payload ).to include( ack: a_hash_including(sender: 'Seabound') )
 		end
 
 	end
@@ -466,7 +600,7 @@ describe Arborist::Node do
 
 
 		it "allows the addition of a Subscription" do
-			sub = Arborist::Subscription.new( 'test', { type: 'host'} )
+			sub = Arborist::Subscription.new {}
 			node.add_subscription( sub )
 			expect( node.subscriptions ).to include( sub.id )
 			expect( node.subscriptions[sub.id] ).to be( sub )
@@ -474,7 +608,7 @@ describe Arborist::Node do
 
 
 		it "allows the removal of a Subscription" do
-			sub = Arborist::Subscription.new( 'test', { type: 'host'} )
+			sub = Arborist::Subscription.new {}
 			node.add_subscription( sub )
 			node.remove_subscription( sub.id )
 			expect( node.subscriptions ).to_not include( sub )
@@ -485,7 +619,7 @@ describe Arborist::Node do
 			events = node.update( 'song' => 'Fear', 'artist' => "Mind.in.a.Box" )
 			delta_event = events.find {|ev| ev.type == 'node.delta' }
 
-			sub = Arborist::Subscription.new( 'node.delta' )
+			sub = Arborist::Subscription.new( 'node.delta' ) {}
 			node.add_subscription( sub )
 
 			results = node.find_matching_subscriptions( delta_event )
@@ -578,5 +712,148 @@ describe Arborist::Node do
 
 	end
 
+
+	describe "secondary dependencies" do
+
+		let( :provider_node_parent ) do
+			concrete_class.new( 'san' )
+		end
+
+		let( :provider_node ) do
+			concrete_class.new( 'san-iscsi' ) do
+				parent 'san'
+			end
+		end
+
+		let( :node ) do
+			concrete_class.new( 'appserver' ) do
+				description "An appserver virtual machine"
+			end
+		end
+
+		let( :manager ) do
+			man = Arborist::Manager.new
+			man.load_tree([ node, provider_node, provider_node_parent ])
+			man
+		end
+
+
+		it "can be declared for a node" do
+			node.depends_on( 'san-iscsi' )
+			expect( node ).to have_dependencies
+			expect( node.dependencies ).to include( 'san-iscsi' )
+		end
+
+
+		it "can't be declared for the root node" do
+			expect {
+				node.depends_on( '_' )
+			}.to raise_exception( Arborist::ConfigError, /root node/i )
+		end
+
+
+		it "can't be declared for itself" do
+			expect {
+				node.depends_on( 'appserver' )
+			}.to raise_exception( Arborist::ConfigError, /itself/i )
+		end
+
+
+		it "can't be declared for any of its ancestors" do
+			provider_node.depends_on( 'san' )
+
+			expect {
+				provider_node.register_secondary_dependencies( manager )
+			}.to raise_exception( Arborist::ConfigError, /ancestor/i )
+		end
+
+
+		it "can't be declared for any of its decendants" do
+			provider_node_parent.depends_on( 'san-iscsi' )
+
+			expect {
+				provider_node_parent.register_secondary_dependencies( manager )
+			}.to raise_exception( Arborist::ConfigError, /descendant/i )
+		end
+
+
+		it "can be declared with a simple identifier" do
+			node.depends_on( 'san-iscsi' )
+
+			expect {
+				node.register_secondary_dependencies( manager )
+			}.to_not raise_exception
+		end
+
+
+		it "can be declared on a service on a host"  do
+			node.depends_on( 'iscsi', on: 'san' )
+			expect( node ).to have_dependencies
+			expect( node.dependencies.behavior ).to eq( :all )
+			expect( node.dependencies.identifiers ).to include( 'san-iscsi' )
+		end
+
+
+		it "can be declared for unrelated identifiers"
+		it "can be declared for related identifiers"
+
+
+		it "can be declared for all of a group of identifiers"
+		it "can be declared for any of a group of identifiers"
+
+
+		it "cause the node to be quieted when the dependent node goes down" do
+			node.depends_on( provider_node.identifier )
+			node.register_secondary_dependencies( manager )
+
+			events = provider_node.update( error: "fatal disk error: offlined" )
+			provider_node.publish_events( *events )
+
+			expect( node ).to be_quieted
+			expect( node ).to have_downed_dependencies
+			# :TODO: Quieted description?
+		end
+
+	end
+
+
+	describe "operational attribute modification" do
+
+
+		let( :node ) do
+			concrete_class.new( 'foo' ) do
+				parent 'bar'
+				description "The prototypical node"
+				tags :chunker, :hunky, :flippin, :hippo
+			end
+		end
+
+
+		it "can change its parent" do
+			node.modify( parent: 'foo' )
+			expect( node.parent ).to eq( 'foo' )
+		end
+
+
+		it "can change its description" do
+			node.modify( description: 'A different node' )
+			expect( node.description ).to eq( 'A different node' )
+		end
+
+
+		it "can change its tags" do
+			node.modify( tags: %w[dew dairy daisy dilettante] )
+			expect( node.tags ).to eq( %w[dew dairy daisy dilettante] )
+		end
+
+
+		it "arrayifies tags modifications" do
+			node.modify( tags: 'single' )
+			expect( node.tags ).to eq( %w[single] )
+		end
+
+
+	end
+
 end