dnapi 1.1.74.jruby192.c

data/spec/environment_spec.rb

@@ -0,0 +1,227 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe DNApi::Environment do
+
+  def instance_info
+    @id ||= 0
+    @id += 1
+    {:id => @id,
+     :public_hostname => "public_host.#{@id}",
+     :private_hostname => "private_host.#{@id}"}
+  end
+
+  def legacy_provision_instance
+    require 'ostruct'
+    OpenStruct.new(instance_info)
+  end
+
+  describe "#db_host" do
+    it 'is the public hostname of the solo instance if the environment consists of a solo instance' do
+      environment = DNApi::Environment.new
+      environment.build_instance(instance_info.merge(:role => :solo))
+      environment.db_host.should eql('public_host.1')
+    end
+
+    it 'is the public hostname of the database server' do
+      environment = DNApi::Environment.new
+      db_instance_info = instance_info
+      environment.build_instance(db_instance_info.merge(:role => :db_master))
+      environment.db_host.should eql(db_instance_info[:public_hostname])
+    end
+
+    it "responds to legacy 'api'" do
+      environment = DNApi::Environment.new
+      instance = legacy_provision_instance
+      environment.build_instance(:role => :db_master, :provisioned => instance)
+      environment.db_host.should eql(instance.public_hostname)
+    end
+  end
+
+  describe "#db_slaves" do
+    it 'is an array of all instances with the db_slave role' do
+      environment = DNApi::Environment.new
+      environment.build_instance(instance_info.merge(:role => :app_master))
+      environment.build_instance(instance_info.merge(:role => :db_master))
+      environment.build_instance(instance_info.merge(:role => :db_slave))
+      environment.build_instance(instance_info.merge(:role => :db_slave))
+      environment.build_instance(instance_info.merge(:role => :db_slave))
+      environment.should have(3).db_slaves
+    end
+  end
+
+  describe "#utility_instances" do
+    it 'is an array of all instances with the utility_instances role' do
+      environment = DNApi::Environment.new
+      environment.build_instance(instance_info.merge(:role => :app_master))
+      environment.build_instance(instance_info.merge(:role => :db_master))
+      environment.build_instance(instance_info.merge(:role => :db_slave))
+      environment.build_instance(instance_info.merge(:role => :util, :name => "foo"))
+      environment.build_instance(instance_info.merge(:role => :util, :name => "bar"))
+      environment.should have(2).utility_instances
+    end
+  end
+
+  describe '#recipes' do
+    it 'includes the stack recipes' do
+      env = DNApi::Environment.new(:stack => DNApi::Stack::NginxMongrel)
+      env.build_app
+      env.recipes.should include(*DNApi::Stack::NginxMongrel.recipes)
+    end
+
+    it 'includes the app recipes' do
+      env = DNApi::Environment.new(:stack => DNApi::Stack::NginxMongrel)
+      env.build_app
+      env.recipes.should include(*DNApi::Recipe.defaults)
+    end
+  end
+
+  describe '#mysql_backup_cron' do
+    it 'is nil if there is no backup_window' do
+      env = DNApi::Environment.new(:backup_window => 0, :db_stack => DNApi::DbStack::Mysql)
+      env.mysql_backup_cron.should be_nil
+    end
+
+    it 'runs eybackup --quiet' do
+      env = DNApi::Environment.new(:backup_window => 1, :db_stack => DNApi::DbStack::Mysql)
+      env.mysql_backup_cron.command.should == 'eybackup --quiet'
+    end
+
+    it 'is 10 past the hour' do
+      env = DNApi::Environment.new(:backup_window => 1, :db_stack => DNApi::DbStack::Mysql)
+      env.mysql_backup_cron.minute.should == '10'
+    end
+
+    it 'is at 1 AM PST if the backup interal is 24 hours' do
+      env = DNApi::Environment.new(:backup_window => 1, :backup_interval => 24, :db_stack => DNApi::DbStack::Mysql)
+      env.mysql_backup_cron.hour.should == '1'
+    end
+
+    it 'is at every other hour if the backup interval is 12 hours' do
+      env = DNApi::Environment.new(:backup_window => 1, :backup_interval => 12, :db_stack => DNApi::DbStack::Mysql)
+      env.mysql_backup_cron.hour.should == '*/12'
+    end
+  end
+
+  describe '#snapshot_cron' do
+    it 'runs ey-snapshots --snapshot --quiet' do
+      env = DNApi::Environment.new(:backup_window => 1)
+      env.snapshot_cron.command.should == 'ey-snapshots --snapshot --quiet'
+    end
+    it 'is in the last half of the hour' do
+      env = DNApi::Environment.new(:backup_window => 1)
+      env.snapshot_cron.minute.should =~ %r{0/[3-5]\d}
+    end
+  end
+
+  describe '#postgres_backup_cron' do
+    it 'runs eybackup -e postgresql --quiet' do
+      env = DNApi::Environment.new(:backup_window => 1, :db_stack => DNApi::DbStack::Postgres)
+      env.postgres_backup_cron.command.should == 'eybackup -e postgresql --quiet'
+    end
+
+    it 'is 20 past the hour' do
+      env = DNApi::Environment.new(:backup_window => 1, :db_stack => DNApi::DbStack::Postgres)
+      env.postgres_backup_cron.minute.should == '20'
+    end
+
+    context "disabled backups" do
+      it 'returns nil when backups are disabled on Postgres DbStack' do
+        env = DNApi::Environment.new(:backup_window => 0, :db_stack => DNApi::DbStack::Postgres)
+        env.postgres_backup_cron.should be_nil
+      end
+
+      it 'returns nil when backups are disabled on Postgres9 DbStack' do
+        env = DNApi::Environment.new(:backup_window => 0, :db_stack => DNApi::DbStack::Postgres9)
+        env.postgres_backup_cron.should be_nil
+      end
+
+      it 'returns nil when backups are disabled on Postgres91 DbStack' do
+        env = DNApi::Environment.new(:backup_window => 0, :db_stack => DNApi::DbStack::Postgres91)
+        env.postgres_backup_cron.should be_nil
+      end
+    end
+  end
+
+  it "has newrelic" do
+    env = DNApi::Environment.new
+
+    env.newrelic_key = "foo"
+    env.newrelic_key.should == "foo"
+
+    env.build_app(:newrelic => true)
+    env.apps.first.newrelic?.should be_true
+
+    env.build_app.newrelic?.should be_false
+  end
+
+  it "ignores disabled instances when listing enabled app servers hostnames" do
+    env = DNApi.gen(:default, 'nginx_passenger', ['rails'])
+    env.build_instance(instance_info.merge(:role => :db_master, :enabled => false))
+    env.build_instance(instance_info.merge(:role => :app_master, :enabled => false))
+    instance = env.build_instance(instance_info.merge(:role => :app, :enabled => false))
+    env.enabled_app_servers_hostnames.should be_empty
+
+    dna = JSON.parse(instance.to_dna.to_json)
+    dna["members"].should be_empty
+  end
+
+  describe '#backup_window' do
+    it 'should default to 14' do
+      DNApi::Environment.new.backup_window.should == 14
+    end
+  end
+
+  describe "#dna_for_instance" do
+    it "raises an error when the instance is not found" do
+      env = DNApi.gen(:default, 'nginx_passenger', [])
+      instance = env.build_instance(instance_info.merge(:role => :solo))
+      lambda { DNApi::Environment.new.dna_for_instance(instance) }.
+        should raise_error(DNApi::InstanceNotFound)
+    end
+  end
+
+  specify "monitoring" do
+    default = DNApi::Environment.new
+    default.monitoring.should be_monit
+    default.monitoring = "god"
+    default.monitoring.should be_god
+
+    monit = DNApi::Environment.new(:monitoring => "monit").monitoring
+    monit.should be_monit
+    monit.name.should  == "monit"
+    monit.label.should == "Monit"
+
+    god = DNApi::Environment.new(:monitoring => "god").monitoring
+    god.should be_god
+    god.name.should  == "god"
+    god.label.should == "god"
+  end
+
+  specify "components" do
+    env = DNApi::Environment.new
+    env.components.should be_empty
+    env.components << DNApi::Component[:god].new
+    env.has_component?(:god).should be_true
+  end
+
+  describe "#components" do
+    it 'dumps components into a hash' do
+      env = DNApi::Environment.new
+      env.add_component(:god)
+      DNApi::Environment.from(JSON.parse(env.to_json)).components.should_not be_empty
+    end
+  end
+
+  describe "#ruby_component" do
+    before(:each) do
+      @env = DNApi::Environment.new
+    end
+
+    DNApi::Components::RubyVersion.all.each do |ruby_component|
+      it "returns #{ruby_component.key_id} when appropriate" do
+        @env.add_component(ruby_component.key_id)
+        @env.ruby_component.should == @env.component(ruby_component.key_id)
+      end
+    end
+  end
+end

data/spec/instance_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe DNApi::Instance do
+  before(:each) do
+    @environment = DNApi::Environment.new
+    @instance = @environment.build_instance(:id => 'default', :role => :app_master)
+  end
+
+  it 'has selectors for environment data' do
+    @instance.apps.should == @environment.apps
+    @instance.recipes.should == @environment.recipes
+    @instance.solo?.should == @environment.solo?
+    @instance.ssh_username == @environment.ssh_username
+    @instance.ssh_password == @environment.ssh_password
+  end
+
+  it "has newrelic attributes when it has the :newrelic component" do
+    @instance.add_component(:newrelic, :seed => 'bar', :token => 'sekretz')
+
+    @instance.newrelic_seed.should == "bar"
+    @instance.newrelic_token.should == "sekretz"
+  end
+
+  it "lacks newrelic attributes when it lacks the :newrelic component" do
+    @instance.should_not have_component(:newrelic)
+    @instance.newrelic_token.should be_nil
+  end
+
+  it "allows adding a ssmtp component" do
+    @instance.add_component(:ssmtp)
+    @instance.should have_component(:ssmtp)
+  end
+
+  it "allows adding a ssmtp component" do
+    @instance.add_component(:exim, :user => "test", :password => "suck", :host => "example.org", :outbound_host => "sendgrid")
+
+    @instance.should have_component(:exim)
+
+    exim = @instance.component(:exim)
+    exim.user.should == "test"
+    exim.password.should == "suck"
+    exim.host.should == "example.org"
+    exim.outbound_host.should == "sendgrid"
+  end
+
+  it 'allows adding multiple volume components' do
+    @instance.add_component(:ebs_volume, :mountpoint => '/data', :size => 5 * 1024 * 1024)
+    @instance.add_component(:ebs_volume, :mountpoint => '/db', :size => 5 * 1024 * 1024)
+
+    @instance.volumes.size.should == 2
+  end
+end

data/spec/proxies.rb

@@ -0,0 +1,143 @@
+class Object
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
+end
+
+module DNApi
+  class ArrayProxy
+    def self.build(array)
+      new(array).build
+    end
+
+    def initialize(array)
+      @array = array
+    end
+
+    def build
+      @positions = (0..(@array.size - 1)).to_a
+      @original_array = @array.deep_clone
+      @array.map! do |value|
+        case value
+        when Hash
+          HashProxy.build(value)
+        when Array
+          ArrayProxy.build(value)
+        else
+          value
+        end
+      end
+      self
+    end
+
+    def index_of(&block)
+      @original_array.each_with_index do |value,i|
+        return i if yield value
+      end
+      raise "Could not find the element in #{inspect}"
+    end
+
+    def size
+      @array.size
+    end
+
+    def empty?
+      @array.empty?
+    end
+
+    def fully_accessed?
+      @positions.empty? && unaccessed_children.empty?
+    end
+
+    def unaccessed
+      {:positions => @positions, :children => unaccessed_children}
+    end
+
+    def unaccessed_children
+      foo = {}
+      @array.each_with_index do |value,i|
+        case value
+        when HashProxy, ArrayProxy
+          foo[i] = value.unaccessed unless value.fully_accessed?
+        when Hash, Array
+          raise "This should be a #{value.class}Proxy: #{value.inspect}"
+        end
+      end
+      foo
+    end
+
+    def [](position)
+      @positions.delete(position)
+      @array[position]
+    end
+
+    def inspect
+      @array.inspect
+    end
+  end
+
+  class HashProxy
+    def self.build(hash)
+      new(hash).build
+    end
+
+    def initialize(hash)
+      @hash = hash
+    end
+
+    def build
+      @keys = @hash.keys
+      @hash.each do |key,value|
+        case value
+        when Hash
+          @hash[key] = HashProxy.build(value)
+        when Array
+          @hash[key] = ArrayProxy.build(value)
+        end
+      end
+      self
+    end
+
+    def has_key?(key)
+      @hash.has_key?(key)
+    end
+
+    def keys
+      @hash.keys
+    end
+
+    def any?
+      @hash.any?
+    end
+
+    def fully_accessed?
+      @keys.empty? && unaccessed_children.empty?
+    end
+
+    def unaccessed
+      {:keys => @keys, :children => unaccessed_children}
+    end
+
+    def unaccessed_children
+      foo = {}
+      @hash.each do |key,value|
+        case value
+        when HashProxy, ArrayProxy
+          foo[key] = value.unaccessed unless value.fully_accessed?
+        when Hash, Array
+          raise "This should be a #{value.class}Proxy: #{key.inspect} #{value.inspect}"
+        end
+      end
+      foo
+    end
+
+    def [](key)
+      @keys.delete(key)
+      @hash[key]
+    end
+
+    def inspect
+      @hash.inspect
+    end
+  end
+end

data/spec/proxies_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/proxies'
+require 'pp'
+require 'sexp_processor' #defines Object#deep_copy
+
+describe DNApi::HashProxy do
+  describe "with no elements" do
+    it "is fully accessed" do
+      DNApi::HashProxy.build({}).should be_fully_accessed
+    end
+  end
+
+  describe "with a single element" do
+    before(:each) do
+      @hash = DNApi::HashProxy.build({:foo => :bar})
+    end
+
+    it "is not fully accessed" do
+      @hash.should_not be_fully_accessed
+    end
+
+    describe "which has been accessed" do
+      it "is fully accessed" do
+        @hash[:foo]
+        @hash.should be_fully_accessed
+      end
+    end
+  end
+
+  describe "with a nested hash" do
+    it "should not be fully accessed unless it's children have been fully accessed" do
+      @hash = DNApi::HashProxy.build({:foo => {:bar => :baz}})
+      lambda { @hash[:foo] }.should_not change { @hash.fully_accessed? }
+      @hash.unaccessed[:keys].should be_empty
+      @hash.unaccessed[:children].should == {:foo => {:keys => [:bar], :children => {}}}
+      @hash[:foo][:bar]
+      @hash.should be_fully_accessed
+    end
+  end
+
+  describe "with a nested array" do
+    it "should not be fully accessed until it's elements have been accessed" do
+      @hash = DNApi::HashProxy.build({:foo => [:bar, :baz]})
+      lambda { @hash[:foo] }.should_not change { @hash.fully_accessed? }
+      @hash.unaccessed[:keys].should be_empty
+      @hash.unaccessed[:children].should == {:foo => {:positions => [0, 1], :children => {}}}
+      @hash[:foo][0]
+      @hash[:foo][1]
+      @hash.should be_fully_accessed
+    end
+  end
+end
+
+describe DNApi::ArrayProxy do
+  describe "with no elements" do
+    it "is fully accessed" do
+      DNApi::ArrayProxy.build([]).should be_fully_accessed
+    end
+  end
+
+  describe "with a single element" do
+    before(:each) do
+      @array = DNApi::ArrayProxy.build([:foo])
+    end
+
+    it "is not fully accessed" do
+      @array.should_not be_fully_accessed
+    end
+
+    describe "which has been accessed" do
+      it "is fully accessed" do
+        @array[0]
+        @array.should be_fully_accessed
+      end
+    end
+  end
+end