ironfan 5.0.11 → 6.0.0

data/spec/ironfan/ec2/elb_spec.rb

@@ -1,17 +1,15 @@
 require 'spec_helper'
 
-require 'ironfan'
-
-cert  = IO.read(File.realpath(File.join(File.dirname(__FILE__), '../../fixtures/ec2/elb/snakeoil.crt')))
-key   = IO.read(File.realpath(File.join(File.dirname(__FILE__), '../../fixtures/ec2/elb/snakeoil.key')))
+cert = File.read Pathname.path_to(:fixtures).join('ec2/elb/snakeoil.crt').to_s
+key  = File.read Pathname.path_to(:fixtures).join('ec2/elb/snakeoil.key').to_s
 
 describe Ironfan::Dsl::Cluster do
-  let (:cluster) do
+  let(:cluster) do
 
-    Ironfan.cluster "sparky" do
+    Ironfan.cluster 'sparky' do
 
       cloud(:ec2) do
-        iam_server_certificate "snake-oil" do
+        iam_server_certificate 'snake-oil' do
           certificate cert
           private_key key
         end
@@ -21,7 +19,7 @@ describe Ironfan::Dsl::Cluster do
         instances 2
         cloud(:ec2) do
 
-          elastic_load_balancer "sparky-elb" do
+          elastic_load_balancer 'sparky-elb' do
             map_port('HTTP',   80, 'HTTP', 81)
             map_port('HTTPS', 443, 'HTTP', 81, 'snake-oil')
             disallowed_ciphers %w[ RC4-SHA ]
@@ -40,52 +38,57 @@ describe Ironfan::Dsl::Cluster do
         end
       end
     end
+
+    Ironfan.cluster('sparky').resolve
   end
 
-  describe 'cluster definition' do
-    subject { cluster }
+  context 'cluster definition' do
+    subject{ cluster }
 
-    its(:name) { should eql "sparky" }
-    its(:environment) { should eql :_default }
-    its(:run_list) { should eql [] }
+    its(:name)       { should eq('sparky')  }
+    its(:environment){ should eq(:_default) }
+    its(:run_list)   { should eq([])        }
 
-    it "should have one IAM server certificate" do
-      cluster.clouds.values.first.iam_server_certificates.values.length.should == 1
+    it 'has one IAM server certificate' do
+      cluster.clouds.values.first.iam_server_certificates.values.length.should eq(1)
     end
 
-    describe 'facets' do
-      before { @facets = cluster.facets }
-      subject { @facets.values }
-      its(:length) { should eql 1 }
+    context 'facets' do
+      let(:facets){ cluster.facets }
+
+      subject{ facets.values }
+
+      its(:length){ should eq(1) }
 
-      describe 'web facet' do
-        before { @facet = @facets.values.first }
-        subject { @facet }
-        its(:name) { should eql "web" }
-        describe "elastic load balancers" do
+      context 'web facet' do
+        subject(:facet){ facets.values.first }
 
-          before { @elb = @facet.clouds.values.first.elastic_load_balancers.values.first }
-          subject { @elb }
-          its(:name) { should eql "sparky-elb" }
+        its(:name){ should eq('web') }
 
-          it "should have two port mappings" do
-            @elb.port_mappings.length.should == 2
+        context 'elastic load balancer' do
+
+          subject(:elb){ facet.clouds.values.first.elastic_load_balancers.values.first }
+
+          its(:name){ should eq('sparky-elb') }
+
+          it 'has two port mappings' do
+            elb.port_mappings.length.should eq(2)
           end
 
-          it "should have just one disallowed SSL cipher" do
-            @elb.disallowed_ciphers.length.should == 1
+          it 'has just one disallowed SSL cipher' do
+            elb.disallowed_ciphers.length.should eq(1)
           end
 
-          describe "health check" do
-            before { @hc = @elb.health_check }
-            subject { @hc }
-            its(:ping_protocol) { should eql 'HTTP' }
-            its(:ping_port) { should eql 82 }
-            its(:ping_path) { should eql '/healthcheck' }
-            its(:timeout) { should eql 4 }
-            its(:interval) { should eql 10 }
-            its(:unhealthy_threshold) { should eql 3 }
-            its(:healthy_threshold) { should eql 2 }
+          context 'health check' do
+            subject(:health_check){ elb.health_check }
+
+            its(:ping_protocol)      { should eq('HTTP')         }
+            its(:ping_port)          { should eq(82)             }
+            its(:ping_path)          { should eq('/healthcheck') }
+            its(:timeout)            { should eq(4)              }
+            its(:interval)           { should eq(10)             }
+            its(:unhealthy_threshold){ should eq(3)              }
+            its(:healthy_threshold)  { should eq(2)              }
           end
 
         end

data/spec/ironfan/ec2/security_group_spec.rb

@@ -1,100 +1,98 @@
 require 'spec_helper'
 
-require 'ironfan'
-
 describe Ironfan::Dsl::Cluster do
-  let (:cluster) do
-    Ironfan.cluster "sparky" do
+  let(:cluster) do
+    Ironfan.cluster 'quirky' do
 
       cloud(:ec2) do
-        security_group(:ssh).authorize_port_range 22..22
+        security_group(:ssh).authorize_port_range(22..22)
         flavor 't1.micro'
       end
 
       facet :web do
-        cloud(:ec2).security_group("sparky-web").authorize_port_range(80)
+        cloud(:ec2).security_group('quirky-web').authorize_port_range(80)
         cloud(:ec2).flavor 'm1.small'
       end
 
       facet :mysql do
         # My what a permissive database you have.
-        cloud(:ec2).security_group("sparky-mysql").authorize_port_range(3306)
+        cloud(:ec2).security_group('quirky-mysql').authorize_port_range(3306)
         cloud(:ec2).flavor 'm1.xlarge'
       end
-
     end
+
+    Ironfan.cluster('quirky').resolve
   end
 
-  describe 'cluster definition' do
-    subject { cluster }
+  context 'cluster definition' do
+    subject{ cluster }
+
+    its(:name)       { should eq('quirky')  }
+    its(:environment){ should eq(:_default) }
+    its(:run_list)   { should eq([])        }
 
-    its(:name) { should eql "sparky" }
-    its(:environment) { should eql :_default }
-    its(:run_list) { should eql [] }
+    context 'facets' do
+      let(:facets){ cluster.facets }
 
-    describe 'facets' do
-      before { @facets = cluster.facets }
-      subject { @facets.values }
-      its(:length) { should eql 2 }
+      subject{ facets.values }
 
-      describe 'web facet' do
-        before { @facet = @facets.values.first }
-        subject { @facet }
-        its(:name) { should eql "web" }
+      its(:length){ should eq(2) }
 
-        it 'should have the correct flavor' do
-          @facet.cloud(:ec2).flavor.should  == 'm1.small'
+      context 'web facet' do
+        subject(:facet){ facets.values.first }
+
+        its(:name){ should eq('web') }
+
+        it 'has the correct flavor' do
+          facet.cloud(:ec2).flavor.should eq('m1.small')
         end
 
-        it 'should have the right number of servers' do
-          @facet.servers.length.should == 1
+        it 'has the right number of servers' do
+          facet.servers.length.should eq(1)
         end
 
-        describe 'security groups' do
-          before { @groups = @facet.clouds.values.first.security_groups.values }
-          subject { @groups }
+        context 'security groups' do
+          subject(:groups){ facet.clouds.values.first.security_groups.values }
 
-          its(:length) { should eql 2 }
+          its(:length){ should eq(2) }
 
           it 'authorizes ssh on port 22 from anywhere' do
-            ssh_auth = @groups.detect { |g| g.name == 'ssh' }
+            ssh_auth = groups.detect{ |g| g.name == 'ssh' }
             ssh_auth.should_not be_nil
-            ssh_auth.range_authorizations.select { |g| g.eql? [22..22, "0.0.0.0/0", "tcp"] }.should_not be_empty
+            ssh_auth.range_authorizations.should include([22..22, '0.0.0.0/0', 'tcp'])
           end
 
           it 'authorizes HTTP on port 80 from anywhere' do
-            http_auth = @groups.detect { |g| g.name == 'sparky-web' }
+            http_auth = groups.detect{ |g| g.name == 'quirky-web' }
             http_auth.should_not be_nil
-            http_auth.range_authorizations.select { |g| g.eql? [80..80, "0.0.0.0/0", "tcp"] }.should_not be_empty
+            http_auth.range_authorizations.should include([80..80, '0.0.0.0/0', 'tcp'])
           end
 
         end
       end
 
-      describe 'mysql facet' do
-        before { @facet = @facets.values.last }
-        subject { @facet }
-        its(:name) { should eql "mysql" }
+      context 'mysql facet' do
+        subject(:facet){ facets.values.last }
 
-        it 'should have the correct flavor' do
-          @facet.cloud(:ec2).flavor.should  == 'm1.xlarge'
+        its(:name){ should eq('mysql') }
+
+        it 'has the correct flavor' do
+          facet.cloud(:ec2).flavor.should eq('m1.xlarge')
         end
 
-        describe 'security groups' do
-          before { @groups = @facet.clouds.values.first.security_groups.values }
-          subject { @groups }
+        context 'security groups' do
+          subject(:groups){ facet.clouds.values.first.security_groups.values }
 
-          its(:length) { should eql 2 }
+          its(:length){ should eq(2) }
 
           it 'authorizes ssh on port 22 from anywhere' do
-            ssh_auth = @groups.detect { |g| g.name == 'ssh' }
-            ssh_auth.should_not be_nil
+            groups.one?{ |g| g.name == 'ssh' }.should be_true
           end
 
           it 'authorizes MySQL on port 3306 from anywhere' do
-            mysql_auth = @groups.detect { |g| g.name == 'sparky-mysql' }
+            mysql_auth = groups.detect{ |g| g.name == 'quirky-mysql' }
             mysql_auth.should_not be_nil
-            mysql_auth.range_authorizations.select { |g| g.eql? [3306..3306, "0.0.0.0/0", "tcp"] }.should_not be_empty
+            mysql_auth.range_authorizations.should include([3306..3306, '0.0.0.0/0', 'tcp'])
           end
 
         end

data/spec/ironfan/manifest_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'ironfan'
 
 describe Ironfan::Dsl::MachineManifest do
   context 'it disregards whether values are strings or symbols' do

data/spec/ironfan/plugin_spec.rb

@@ -1,46 +1,60 @@
-require_relative '../spec_helper.rb'
+require 'spec_helper.rb'
 
-describe MyPlugin do
-  subject { MyPlugin }
+describe Ironfan::Plugin::Base do
+  
+  let(:target_class){ Class.new }
+  let(:plugin_class) do   
+    plugin_base = described_class
+    other_class = target_class
+    Class.new do
+      include plugin_base
+      register_with other_class
 
-  it 'should respond to template' do
-    subject.should(respond_to(:template))
+      def self.plugin_hook(*_) end
+    end
   end
 
-  context 'when templatizing plugins' do
-    after(:each) do
-      uncreate_plugin(subject, Foo)
-    end
-    before(:each) do
-      subject.template(%w[baz bif])
-    end
+  subject(:example_plugin){ plugin_class }
+  
+  context '.template' do
+    before(:each){ example_plugin.template %w[baz bif] }
 
-    it 'should create them as classes within itself' do
-      subject.constants.should(include(:BazBif))
+    it 'defines templates as classes within itself' do
+      example_plugin.const_defined?(:BazBif).should be_true
     end
-    it 'should create them as subclasses of itself' do
-      subject.const_get(:BazBif).should(be < subject)
+    
+    it 'defines templates as subclasses of itself' do
+      example_plugin.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))
+    
+    it 'allows for customizing class definitions' do
+      example_plugin.template(%w[gig bag]){ def bam() ; end }
+      example_plugin.const_get(:GigBag).new.should respond_to(:bam)
     end
-    it 'should register methods on the specified class' do
-      Foo.new.should(respond_to(:baz_bif))
+
+    it 'registers methods on the template class' do
+      target_class.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
+
+    it 'wires those methods to the plugin_hook method of itself' do
+      target = target_class.new
+      example_plugin.should_receive(:plugin_hook).with(target, {}, :baz, :baz_bif)
+      target.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)))
+
+    it 'registers the newly created class' do
+      target_class.registry[:baz_bif].should be(example_plugin.const_get(:BazBif))
     end
   end
 end
 
 describe Ironfan::Dsl::Component do
+
+  def uncreate_plugin(plugin_class, target_class)
+    target_class.registry.clear
+    plugin_class.instance_eval{ remove_const :BazBif }
+  end
+
   before(:each) do
     Ironfan::Dsl::Component.template(%w[baz bif]) do
       include Ironfan::Dsl::Component::Announcement
@@ -154,7 +168,8 @@ describe Ironfan::Dsl::Component do
     end
 
     after(:each) do
-      [:BamServer, :BamClient, :PowServer, :PowClient,
+      [
+       :BamServer, :BamClient, :PowServer, :PowClient,
        :ZapClient, :ZapServer, :BopServer, :BopClient,
        ].each do |class_name|
         Ironfan::Dsl::Component.send(:remove_const, class_name)
@@ -162,28 +177,28 @@ describe Ironfan::Dsl::Component do
     end
 
     it 'configures the correct security groups during discovery' do
-      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 = Ironfan.realm(:wap).cluster(:foo).security_group('foo')
+      bar_group = Ironfan.realm(:wap).cluster(:bar).security_group('bar')
 
-      foo_group.group_authorized_by.should include('wap_bar')
-      bar_group.group_authorized_by.should include('wap_foo')
+      foo_group.group_authorized_by.should include('bar')
+      bar_group.group_authorized_by.should include('foo')
     end
 
     it 'configures the correct security groups during bidirectional discovery' do
-      baz_group = Ironfan.realm(:wap).cluster(:baz).cloud(:ec2).security_group('wap_baz')
-      bif_group = Ironfan.realm(:wap).cluster(:bif).cloud(:ec2).security_group('wap_bif')
+      baz_group = Ironfan.realm(:wap).cluster(:baz).security_group('baz')
+      bif_group = Ironfan.realm(:wap).cluster(:bif).security_group('bif')
 
-      baz_group.group_authorized_by.should include('wap_bif')
-      baz_group.group_authorized.should    include('wap_bif')
+      baz_group.group_authorized_by.should include('bif')
+      baz_group.group_authorized.should    include('bif')
     end
 
     it 'does not configure extra security groups during bidirectional discovery' do
-      Ironfan.realm(:wap).cluster(:baz).cloud(:ec2).security_groups.keys.should_not include('wap_bif')
+      Ironfan.realm(:wap).cluster(:baz).security_groups.keys.should_not include('wap_bif')
     end
 
     it 'correctly sets the server cluster even when the client and server facets differ' do
-      bam_wak_group = Ironfan.realm(:wap).cluster(:bam).facet(:wak).cloud(:ec2).security_group('wap_bam')
-      bam_wak_group.group_authorized_by.should include('wap_bop')
+      bam_wak_group = Ironfan.realm(:wap).cluster(:bam).facet(:wak).security_group('bam-wak')
+      bam_wak_group.group_authorized_by.should include('bop')
     end
 
   end

data/spec/ironfan/realm_spec.rb

@@ -1,48 +1,56 @@
 require 'spec_helper'
 
-require 'ironfan'
-
-describe Ironfan::Dsl::Realm do
+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", },
+      { image_id: 'ami-29fe7640', ssh_user: 'bam', bootstrap_distro: 'ubuntu12.04-ironfan' },
     })
 
     Ironfan.realm(:foo) do
-      environment :bif
+      environment   :bif
 
       cloud(:ec2) do
-        flavor 'm1.xlarge'
-        image_name 'ironfan-precise'
+        flavor      'm1.xlarge'
+        image_name  'ironfan-precise'
       end
       
       cluster(:bar) do
         cluster_role.override_attributes(a: 1)
+
         facet(:baz) do
           instances 1
-          role :blah
+          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
+  after(:each) do
+    Ironfan.clusters.clear
+    Ironfan.realms.clear
   end
 
-  it 'should choose its own name as its default environment' do
-    Ironfan.realm(:bar).environment.to_s.should == 'bar'
+  def manifest    
+    Ironfan.cluster(:bar).resolve.facets[:baz].server(0).to_machine_manifest
   end
 
-  it 'should choose the widest possible cookbook contraints to satisfy all plugins' do
-    Ironfan::Dsl::Component.template(%w[bam pow]) do
+  it 'chooses its own name as its default environment' do
+    Ironfan.realm(:bar){ }.environment.to_s.should == 'bar'
+  end
+
+  it 'chooses the widest possible cookbook contraints to satisfy all plugins' do
+    Ironfan::Dsl::Component.template(%w[jib jab]) do
+      require_strict_versioning false
+
       cookbook_req 'bif', '>= 1.0.0'
       def project(_) end
     end
 
-    Ironfan::Dsl::Component.template(%w[jam wam]) do
+    Ironfan::Dsl::Component.template(%w[dig dug]) do
+      require_strict_versioning false
+
       cookbook_req 'bif', '>= 2.0.0'
       def project(_) end
     end
@@ -50,20 +58,24 @@ describe Ironfan::Dsl::Realm do
     Ironfan.realm(:qux) do
       cluster(:cuz) do
         facet(:lix) do
-          bam_pow
-          jam_wam
+          jib_jab
+          dig_dug
         end
       end
     end.cookbook_reqs['bif'].should == '>= 2.0.0'
   end
 
-  it 'should complain when no cookbook constraints can satisfy all plugins' do
+  it 'complains when no cookbook constraints can satisfy all plugins' do
     Ironfan::Dsl::Component.template(%w[bam pow]) do
+      require_strict_versioning false
+
       cookbook_req 'bif', '~> 1.0.0'
       def project(_) end
     end
 
     Ironfan::Dsl::Component.template(%w[jam wam]) do
+      require_strict_versioning false
+
       cookbook_req 'bif', '>= 2.0.0'
       def project(_) end
     end
@@ -80,10 +92,10 @@ describe Ironfan::Dsl::Realm do
     expect{ Ironfan.realm(:qux).cookbook_reqs }.to raise_error
   end
 
-  it 'should create clusters that can be referenced later' do
-    x = self
+  it 'creates clusters that can be referenced later' do
+    test_scope = self
     Ironfan.realm :xx do
-      cluster(:bar).should(x.be(cluster(:bar)))
+      cluster(:bar).should test_scope.be(cluster(:bar))
     end
   end
 
@@ -93,22 +105,22 @@ describe Ironfan::Dsl::Realm do
       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)
+    Ironfan.cluster(:baz).facets.to_a.should_not(be_empty)
+    Ironfan.cluster(: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)
+    Ironfan.cluster(: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)
+    Ironfan.cluster(:bar).facets[:baz].server(0).should_not(be_nil)
   end
 
-  it 'should create clusters with attributes correctly applied' do
+  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]]
+    manifest.run_list.should == %w[role[blah] role[bar-cluster] role[bar-baz-facet]]
   end
 
   it 'should create clusters with the correct ssh user' do
@@ -118,7 +130,7 @@ describe Ironfan::Dsl::Realm do
 
   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.realm(:foo).clusters[: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'
@@ -126,12 +138,12 @@ describe Ironfan::Dsl::Realm do
 
   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
+    Ironfan.realm(:foo).resolve.clusters[:bar].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
+    Ironfan.cluster(:bar).resolve.facets[:baz].environment.should == :bif
   end
 end

data/spec/spec_helper.rb

@@ -1,53 +1,39 @@
-$:.unshift File.expand_path('../../lib', __FILE__)
-require 'chef'
-require 'chef/knife'
+if ENV['IRONFAN_COV']
+  require 'simplecov'
+  SimpleCov.start
+end
+
 require 'ironfan'
+require 'chef/cluster_knife'
 require 'fog'
 Fog.mock!
 Fog::Mock.delay = 0
 
 require 'gorillib/pathname'
 
-Pathname.register_paths(
-  code:        File.expand_path('../..', __FILE__),
-  fixtures:    [:code, 'spec', 'fixtures'],
-  )
+Pathname.register_paths(code:     File.expand_path('../..', __FILE__),
+                        spec:     [:code, 'spec'],
+                        fixtures: [:spec, 'fixtures'],
+                        support:  [:spec, 'support'])
+
+Dir[Pathname.path_to(:support).join('**/*.rb')].each{ |f| require f }
 
 RSpec.configure do |cfg|
   def ironfan_go!
     k = Chef::Knife.new
-    k.config[:config_file] = Pathname.path_to(:fixtures, 'knife/knife.rb')
+    k.config[:config_file] = Pathname.path_to(:fixtures, 'knife/knife.rb').to_s
     k.configure_chef
     Chef::Config.instance_eval do
-      knife.merge!({
-          :aws_access_key_id => 'access_key',
-          :aws_secret_access_key => 'secret',
-        })
-      cluster_path Pathname.path_to(:fixtures).to_s
+      knife.merge!(aws_access_key_id:     'access_key',
+                   aws_secret_access_key: 'secret')
+      cluster_path Pathname.path_to(:fixtures).join('clusters').to_s
     end
 
-    require 'ironfan'
-
     Ironfan.ui          = Chef::Knife::UI.new(STDOUT, STDERR, STDIN, {})
-    Ironfan.chef_config = k.config
-    Ironfan.cluster_path
+    Ironfan.knife_config = k.config
   end
 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