ironfan 4.12.3 → 5.0.0

data/spec/ironfan/diff_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+require 'gorillib/diff'
+require_relative '../spec_helper/dummy_diff_drawer.rb'
+
+describe Gorillib::DiffFormatter do
+  it 'writes the indices of displayed elements for both sides' do
+    TestDrawer.diffing_objs([1], [1,2]) do |drawer|
+      drawer.should_receive(:display_indices).with(1,1)
+    end
+  end
+  it 'adds objects correctly on the right' do
+    TestDrawer.diffing_objs([1], [1,2]) do |drawer|
+      drawer.should_receive(:display_add).with(nil, 2)
+    end
+  end
+  it 'labels objects correctly on the right' do
+    TestDrawer.diffing_objs([1], [1,2]) do |drawer|
+      # meaning it displayed the name of the right object
+      drawer.should_receive(:b_right)
+    end
+  end
+  it 'adds objects correctly on the left' do
+    TestDrawer.diffing_objs([1,2], [1]) do |drawer|
+      drawer.should_receive(:display_add).with(2, nil)
+    end
+    TestDrawer.diffing_objs([1,2], [1]) do |drawer|
+      # meaning it displayed the name of the left object
+      drawer.should_receive(:b_left)
+    end
+  end
+  it 'lists keys only on the left correctly' do
+    TestDrawer.diffing_objs({a: 1, b: 2}, {a: 1}) do |drawer|
+      drawer.should_receive(:only_left_key).with(:b)
+    end
+  end
+  it 'lists keys only on the right correctly' do
+    TestDrawer.diffing_objs({a: 1}, {a: 1, b: 2}) do |drawer|
+      drawer.should_receive(:only_right_key).with(:b)
+    end
+  end
+  it 'explains when elements differ' do
+    TestDrawer.diffing_objs(1, 2) do |drawer|
+      drawer.should_receive(:display_noteql_atoms).with(1,2)
+    end
+  end
+  it 'explains when elements are of different classes' do
+    TestDrawer.diffing_objs([], {}) do |drawer|
+      drawer.should_receive(:display_hetero).with([],{})
+    end
+  end
+  it 'initializes itself every time it diffs a new pair of objects object' do
+    diff_formatter = TestDrawer.diff_formatter
+
+    diff_formatter.should_receive :setup
+    diff_formatter.display_diff(nil, nil)
+    diff_formatter.should_receive :setup
+    diff_formatter.display_diff(nil, nil)
+  end
+
+  it 'correctly diffs complex objects' do
+
+    # These aren't incredibly descriptive, but they are nice for
+    # bug-hunting.
+
+    TestDrawer.transform_ltor(1,2)
+    TestDrawer.transform_ltor([1], [1,2])
+    TestDrawer.transform_ltor({a: 1}, {a: 1, b: 2})
+    TestDrawer.transform_ltor([1,2], [1])
+    TestDrawer.transform_ltor({a: 1, b: 2}, {a: 1})
+    TestDrawer.transform_ltor({a: 1, b: 2}, {a: 1, c: 3})
+    TestDrawer.transform_ltor({a: [1]}, {a: [1,2]})
+    TestDrawer.transform_ltor({a: [1,2]}, {a: [1]})
+    TestDrawer.transform_ltor({a: [1]}, {a: [1,2]})
+    TestDrawer.transform_ltor({a: [1]}, {a: [1,2]})
+    TestDrawer.transform_ltor({a: [1], b: 3, c: {a: 1}, d: []}, {a: [1,2], c: [7,8], d: {a: 2}})
+    TestDrawer.transform_ltor([], [[1,2]])
+  end
+end

data/spec/ironfan/dsl_spec.rb

@@ -0,0 +1,115 @@
+require 'spec_helper'
+require 'ironfan'
+
+describe Ironfan::Dsl do
+  context 'when joining requirement pairs' do
+    subject{ Ironfan::Dsl.new }
+
+    def test_join(cn1, cn2)
+      name = 'foo'
+      subject.join_req(Ironfan::Plugin::CookbookRequirement.new(name: name, constraint: cn1),
+                       Ironfan::Plugin::CookbookRequirement.new(name: name, constraint: cn2)).constraint
+    end
+
+    it 'joins =,= requirements when valid' do
+      test_join('= 1.0.0', '= 1.0.0').should == '= 1.0.0'
+    end
+    it 'raises when =,= requirements not valid' do
+      expect{ test_join('= 1.0.0', '= 2.0.0') }.to raise_error
+    end
+    it 'chooses the more restrictive constraint for >= , >= requirements' do
+      test_join('>= 1.0.0', '>= 2.0.0').should == '>= 2.0.0'
+      test_join('>= 2.0.0', '>= 1.0.0').should == '>= 2.0.0'
+    end
+    it 'chooses the more restrictive constraint for ~> , ~> requirements' do
+      test_join('~> 1.0', '~> 1.2').should == '~> 1.2'
+      test_join('~> 1.2', '~> 1.0').should == '~> 1.2'
+    end
+    it 'raises when ~> , ~> requirements not valid' do
+      expect{ test_join('~> 1.0', '~> 1.0.0') }.to raise_error
+      expect{ test_join('~> 1.0', '~> 2.0') }.to raise_error
+      expect{ test_join('~> 2.0', '~> 1.0') }.to raise_error
+    end
+    it 'joins =, >= requirements when valid' do
+      test_join('= 1.1.0', '>= 1.1.0').should == '= 1.1.0'
+      test_join('>= 1.1.0', '= 1.1.0').should == '= 1.1.0'
+    end
+    it 'raises when =, >= requirements not valid' do
+      expect{ test_join('= 1.0.0', '>= 1.1.0') }.to raise_error
+      expect{ test_join('>= 1.1.0', '= 1.0.0') }.to raise_error
+    end
+    it 'joins =, ~> requirements when valid' do
+      test_join('= 1.1.0', '~> 1.0').should == '= 1.1.0'
+      test_join('~> 1.0', '= 1.1.0').should == '= 1.1.0'
+    end
+    it 'raises when =, ~> requirements not valid' do
+      expect{ test_join('= 2.0.0', '~> 1.0') }.to raise_error
+      expect{ test_join('~> 1.0', '= 2.0.0') }.to raise_error
+    end
+    it 'joins >=, ~> requirements when valid' do
+      test_join('>= 1.1.0', '~> 1.1.2').should == '~> 1.1.2'
+      test_join('~> 1.1.2', '>= 1.1.0').should == '~> 1.1.2'
+    end
+    it 'raises when >=, ~> requirements not valid' do
+      expect{ test_join('>= 1.1.3', '~> 1.1.2') }.to raise_error
+      expect{ test_join('~> 1.1.2', '>= 1.1.3') }.to raise_error
+    end
+  end
+
+  context 'when aggregating requirements' do
+    before(:each) do
+      Ironfan::Dsl.class_eval{ @@testing = true }
+
+      Ironfan::Dsl::Component.template(%w[foo]) do
+        cookbook_req 'a', '>= 1.2.3'
+        def project(*_) end
+      end
+      Ironfan::Dsl::Component.template(%w[bar]) do
+        cookbook_req 'a', '>= 1.2.5'
+        def project(*_) end
+      end
+      Ironfan::Dsl::Component.template(%w[baz]) do
+        cookbook_req 'a', '>= 1.2.7'
+        def project(*_) end
+      end
+      Ironfan.realm(:test) do
+        cluster(:just_foo) do
+          foo
+        end
+        cluster(:foo_bar) do
+          foo; bar
+        end
+        cluster(:nest_foo_bar) do
+          foo
+          facet(:bar) do
+            bar
+          end
+        end
+        cluster(:baz) do
+          baz          
+        end
+      end
+    end
+
+    after(:each) do
+      [:Foo, :Bar, :Baz].each{|x| Ironfan::Dsl::Component.send(:remove_const, x)}
+    end
+
+    it 'correctly merges version requirements in simple cases' do
+      Ironfan.realm(:test).tap do |realm|
+        realm.cluster(:just_foo).cookbook_reqs['a'].should == '>= 1.2.3'
+        realm.cluster( :foo_bar).cookbook_reqs['a'].should == '>= 1.2.5'
+      end
+    end
+
+    it 'correctly handles nested versions requirements' do
+      Ironfan.realm(:test).tap do |realm|
+        realm.cluster(:nest_foo_bar).tap do |cluster|
+          cluster            .cookbook_reqs['a'].should == '>= 1.2.5'
+          cluster.facet(:bar).cookbook_reqs['a'].should == '>= 1.2.5'
+        end
+        realm.cookbook_reqs['a'].should == '>= 1.2.7'
+      end
+    end
+  end
+end

data/spec/ironfan/manifest_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'ironfan'
+
+describe Ironfan::Dsl::MachineManifest do
+  context 'it disregards whether values are strings or symbols' do
+    before(:each) do
+      Ironfan::Dsl::Component.template(%w[baz bif]) do
+        collection :bams, Symbol
+        magic :pow, Whatever
+      end
+    end
+
+    def comparable_manifest(hsh)
+      Ironfan::Dsl::MachineManifest.receive(components: [Ironfan::Dsl::Component::BazBif.new(hsh)]).to_comparable
+    end
+
+    it 'when those values are contained in an array of within its serialization' do
+      comparable_manifest(bam: [:a, :b, :c]).should == comparable_manifest(bam: %w[a b c])
+      comparable_manifest(pow: [:a, :b, :c]).should == comparable_manifest(pow: %w[a b c])
+    end
+    it 'when those values are contained in hash within its serialization' do
+      comparable_manifest(pow: {a: 'a'}).should == comparable_manifest(pow: {'a' => :a})
+    end
+    it 'correctly stores the chef environment' do
+      node = Chef::Node.json_create('chef_environment' => 'buzi', 'recipes' => [])
+      Ironfan::Dsl::MachineManifest.from_remote(nil, nil, nil, node, nil, nil, nil, nil, nil).environment.to_s.should == 'buzi'
+    end
+  end
+end

data/spec/ironfan/plugin_spec.rb

@@ -0,0 +1,138 @@
+require_relative '../spec_helper.rb'
+
+describe MyPlugin do
+  subject { MyPlugin }
+
+  it 'should respond to template' do
+    subject.should(respond_to(:template))
+  end
+
+  context 'when templatizing plugins' do
+    after(:each) do
+      uncreate_plugin(subject, Foo)
+    end
+    before(:each) do
+      subject.template(%w[baz bif])
+    end
+
+    it 'should create them as classes within itself' do
+      subject.constants.should(include(:BazBif))
+    end
+    it 'should create them as subclasses of itself' do
+      subject.const_get(:BazBif).should(be < subject)
+    end
+    it 'should allow customizing the classes' do
+      uncreate_plugin(subject, Foo)
+      subject.template(%w[baz bif]){ def bam() end }
+      subject.const_get(:BazBif).new.should(respond_to(:bam))
+    end
+    it 'should register methods on the specified class' do
+      Foo.new.should(respond_to(:baz_bif))
+    end
+    it 'should wire those methods to the plugin_hook method of itself' do
+      foo = Foo.new
+      subject.should_receive(:plugin_hook).with(foo, {}, :baz, :baz_bif)
+      foo.baz_bif
+    end
+    it 'should allow the user to create a custom class that will also be registered' do
+      Foo.registry[:baz_bif].should(be(subject.const_get(:BazBif)))
+    end
+  end
+end
+
+describe Ironfan::Dsl::Component do
+  before(:each) do
+    Ironfan::Dsl::Component.template(%w[baz bif]) do
+      include Ironfan::Dsl::Component::Announcement
+
+      magic :bam, Symbol, node_attr: 'a.b.c', default: nil
+
+      def project(compute)
+        compute.role(:called_from_project, compute) unless bam
+      end
+    end
+  end
+
+  after(:each) do
+    uncreate_plugin(Ironfan::Dsl::Component, Ironfan::Dsl::Compute)
+  end
+
+  it 'should have its project method called by the plugin_hook' do
+    Ironfan.cluster(:foo) do
+      should_receive(:role).with(:called_from_project, self)
+      baz_bif
+    end
+  end
+
+  it 'should merge its node attribute to create a node' do
+    node = Chef::Node.new
+    node.set['a'] = {'b' => {'c' => :baz}}
+    Ironfan.cluster(:foo) do
+      baz_bif{ bam(:baz) }.to_node.to_hash.should == node.to_hash
+    end
+  end
+  it 'should be instantiable from a node object' do
+    node = Chef::Node.new
+    node.set['a'] = {'b' => {'c' => :baz}}
+    Ironfan::Dsl::Compute.registry[:baz_bif].from_node(node).bam.should == :baz
+  end
+
+  it 'should remember all of its node attributes' do
+    Ironfan.cluster(:foo) do
+      component = baz_bif{ bam(:baz) }
+      component.to_node.to_hash.should ==
+        Ironfan::Dsl::Compute.registry[:baz_bif].from_node(component.to_node).to_node.to_hash
+    end
+  end
+
+  context 'when announcing' do
+    before (:each) do
+      def make_plugin(name, server_b)
+        Ironfan::Dsl::Component.template([name, server_b ? 'server' : 'client']) do
+          include Ironfan::Dsl::Component::Announcement if server_b
+          include Ironfan::Dsl::Component::Discovery    if not server_b
+
+          if server_b
+            def project(compute)
+            end
+          else
+            def project(compute)
+              set_discovery compute, [announce_name]
+            end
+          end
+        end
+      end
+
+      def make_plugin_pair(name) make_plugin(name, true); make_plugin(name, false); end
+
+      make_plugin_pair(:bam); make_plugin_pair(:pow)
+    end
+
+    it 'automatically discovers announcements within realms' do
+      Ironfan.realm(:wap) do
+        cluster(:foo){ bam_client; pow_server }
+        cluster(:bar){ bam_server; pow_client }
+
+        cluster(:foo).cluster_role.override_attributes[:discovers].should == {bam: :wap_bar}
+        cluster(:bar).cluster_role.override_attributes[:discovers].should == {pow: :wap_foo}
+      end
+    end
+
+    it 'automatically configures security groups during discovery' do
+      Ironfan.realm(:wap) do
+        cloud(:ec2)
+
+        cluster(:foo){ bam_client; pow_server }
+        cluster(:bar){ bam_server; pow_client }
+      end.resolve!
+
+      rspec = self
+
+      foo_group = Ironfan.realm(:wap).cluster(:foo).cloud(:ec2).security_group('wap_foo')
+      bar_group = Ironfan.realm(:wap).cluster(:bar).cloud(:ec2).security_group('wap_bar')
+
+      foo_group.group_authorized.should include('wap_bar')
+      bar_group.group_authorized.should include('wap_foo')
+    end
+  end
+end

data/spec/ironfan/realm_spec.rb

@@ -0,0 +1,137 @@
+require 'spec_helper'
+
+require 'ironfan'
+
+describe Ironfan::Dsl::Realm do
+  before(:each) do
+    (Chef::Config[:ec2_image_info] ||= {}).merge!({
+      %w[us-east-1  64-bit  ebs     ironfan-precise  ] =>
+      { :image_id => 'ami-29fe7640', :ssh_user => 'bam', :bootstrap_distro => "ubuntu12.04-ironfan", },
+    })
+
+    Ironfan.realm(:foo) do
+      environment :bif
+
+      cloud(:ec2) do
+        flavor 'm1.xlarge'
+        image_name 'ironfan-precise'
+      end
+      
+      cluster(:bar) do
+        cluster_role.override_attributes(a: 1)
+        facet(:baz) do
+          instances 1
+          role :blah
+          facet_role.override_attributes(b: 1)
+        end
+      end
+    end
+  end
+
+  def manifest
+    Ironfan.cluster(:foo_bar).facets[:baz].server(0).to_machine_manifest
+  end
+
+  it 'should choose its own name as its default environment' do
+    Ironfan.realm(:bar).environment.to_s.should == 'bar'
+  end
+
+  it 'should choose the widest possible cookbook contraints to satisfy all plugins' do
+    Ironfan::Dsl::Component.template(%w[bam pow]) do
+      cookbook_req 'bif', '>= 1.0.0'
+      def project(_) end
+    end
+
+    Ironfan::Dsl::Component.template(%w[jam wam]) do
+      cookbook_req 'bif', '>= 2.0.0'
+      def project(_) end
+    end
+
+    Ironfan.realm(:qux) do
+      cluster(:cuz) do
+        facet(:lix) do
+          bam_pow
+          jam_wam
+        end
+      end
+    end.cookbook_reqs['bif'].should == '>= 2.0.0'
+  end
+
+  it 'should complain when no cookbook constraints can satisfy all plugins' do
+    Ironfan::Dsl::Component.template(%w[bam pow]) do
+      cookbook_req 'bif', '~> 1.0.0'
+      def project(_) end
+    end
+
+    Ironfan::Dsl::Component.template(%w[jam wam]) do
+      cookbook_req 'bif', '>= 2.0.0'
+      def project(_) end
+    end
+
+    Ironfan.realm(:qux) do
+      cluster(:cuz) do
+        facet(:lix) do
+          bam_pow
+          jam_wam
+        end
+      end
+    end
+
+    expect{ Ironfan.realm(:qux).cookbook_reqs }.to raise_error
+  end
+
+  it 'should create clusters that can be referenced later' do
+    x = self
+    Ironfan.realm :xx do
+      cluster(:bar).should(x.be(cluster(:bar)))
+    end
+  end
+
+  it 'should create clusters that can be edited later' do
+    Ironfan.realm :xy do
+      cluster(:baz)
+      cluster(:baz){ facet :bif }
+    end
+
+    Ironfan.cluster(:xy_baz).facets.to_a.should_not(be_empty)
+    Ironfan.cluster(:xy_baz).servers.to_a.first.should_not(be_nil)
+  end
+
+  it 'should create clusters with names prefixed by its own' do
+    Ironfan.cluster(:foo_bar).should_not(be_nil)
+  end
+
+  it 'should create clusters with machines' do
+    Ironfan.cluster(:foo_bar).facets[:baz].server(0).should_not(be_nil)
+  end
+
+  it 'should create clusters with attributes correctly applied' do
+    manifest.cluster_override_attributes.should == {a: 1}
+    manifest.facet_override_attributes.should == {b: 1}
+    manifest.run_list.should == %w[role[blah] role[foo_bar-cluster] role[foo_bar-baz-facet]]
+  end
+
+  it 'should create clusters with the correct ssh user' do
+    manifest.flavor.should == 'm1.xlarge'
+    manifest.ssh_user.should == 'bam'
+  end
+
+  it 'should save cloud properties to be shared among all clusters within the realm' do
+    # We need to resolve before the cloud settings come through
+    Ironfan.realm(:foo).clusters[:foo_bar].resolve.facets[:baz].servers.to_a.first.to_machine_manifest.flavor.should == 'm1.xlarge'
+
+    # Ironfan.cluster will do the resolution for us.
+    manifest.flavor.should == 'm1.xlarge'
+  end
+
+  it 'should save an environment to be shared among all clusters within the realm' do
+    # We need to resolve before the cloud settings come through
+    Ironfan.realm(:foo).clusters[:foo_bar].resolve.facets[:baz].environment.should == :bif
+
+    # The server manifest should contain the environment.
+    manifest.environment.should == :bif
+
+    # Ironfan.cluster will do the resolution for us.
+    Ironfan.cluster(:foo_bar).facets[:baz].environment.should == :bif
+  end
+end

data/spec/spec_helper/dummy_diff_drawer.rb

@@ -0,0 +1,94 @@
+require 'gorillib/diff'
+require 'stringio'
+
+module TransformLeftToRight
+  attr_reader :left
+
+  DELETE_ME = Object.new
+
+  def display_key_header(key)
+    @left_lineage << [@left, key]
+    @left = @left[key]
+
+    @right_lineage << @right
+    @right = @right[key]
+  end
+
+  def only_left_key(_)
+    @left = DELETE_ME
+  end
+
+  def only_right_key(key)
+    @left = @right
+  end
+
+  def display_add(this, other)
+    if this.nil?
+      @left.insert(@ix, other)
+      @ix += 1
+    else
+      @left.delete_at(@ix)
+    end
+  end
+
+  def display_hetero(this, other)
+    @ix += 1
+    @left = @right
+  end
+
+  def display_noteql_items(*args)
+    @in_array = true
+    super(*args)
+    @in_array = false
+  end
+
+  def display_noteql_atoms(this, other)
+    @ix += 1
+    @left = @right
+  end
+
+  def decrease_indentation
+    tmp = @left
+    @left,key = @left_lineage.pop
+
+    if tmp.equal?(DELETE_ME)
+      @left.delete(key)
+    else
+      @left[key] = tmp
+    end
+
+    @right = @right_lineage.pop
+  end
+
+  def increase_indentation() end
+  def indent() end
+
+  def display_indices(ixl, ixr)
+    @ix = ixr
+  end
+end
+
+class TestDrawer
+  include Gorillib::DiffDrawerMethods
+  include TransformLeftToRight
+
+  def initialize this = nil, other = nil
+    @left_lineage = [@left = this]
+    @right_lineage = [@right = other]
+    @ix = 0
+  end
+  
+  def self.diffing_objs this, other
+    diff_formatter.display_diff(this, other)
+  end
+
+  def self.diff_formatter(drawer = nil)
+    Gorillib::DiffFormatter.new(stream: StringIO.new, drawer: drawer)
+  end
+
+  def self.transform_ltor this, other
+    drawer = new(this, other)
+    Gorillib::DiffFormatter.new(drawer: drawer).display_diff(this, other)
+    drawer.left.should == other
+  end
+end

data/spec/spec_helper.rb

@@ -1,6 +1,7 @@
 $:.unshift File.expand_path('../../lib', __FILE__)
 require 'chef'
 require 'chef/knife'
+require 'ironfan'
 require 'fog'
 Fog.mock!
 Fog::Mock.delay = 0
@@ -36,3 +37,17 @@ end
 require 'chef_zero/server'
 server = ChefZero::Server.new(port: 4000)
 server.start_background
+
+def uncreate_plugin(plugin_class, target_class)
+  target_class.registry.clear
+  plugin_class.instance_eval{ remove_const :BazBif }
+end
+
+class Foo
+end
+
+class MyPlugin
+  include Ironfan::Plugin::Base; register_with Foo
+
+  def self.plugin_hook(*_) end
+end