vagrant-rimu 0.0.1

data/spec/vagrant-rimu/actions/rebuild_spec.rb

@@ -0,0 +1,148 @@
+require 'pathname'
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StopInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::Rebuild do
+  let(:ssh) { double('ssh') }
+  let(:servers) { double('servers') }
+  let(:machine) { double('machine') }
+  let(:reinstall) { double('reinstall') }
+  let(:communicate) { double('communicate') }
+  let(:id) { '200' }
+
+  let(:config) do
+    double.tap do |config|
+      config.stub(:api_url) { nil }
+      config.stub(:api_key) { 'foo' }
+      config.stub(:host_name) { 'rimu.example.com' }
+      config.stub(:root_password) { nil }
+      config.stub(:distro_code) { nil }
+      config.stub(:control_panel) { nil }
+      config.stub(:vps_to_clone) { nil }
+      config.stub(:minimal_init) { nil }
+      config.stub(:disk_space_mb) { nil }
+      config.stub(:memory_mb) { nil }
+      config.stub(:disk_space_2_mb) { nil }
+      config.stub(:setup?) { true }
+      ssh.stub(:username) { 'rimu' }
+      ssh.stub(:username=) { 'rimu' }
+      ssh.stub(:private_key_path) { 'test/test_rimu_id_rsa' }
+      config.stub(:ssh) { ssh }
+    end
+  end
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        servers.stub(:reinstall) { reinstall }
+        os.stub(:servers) { servers }
+      end
+      machine.stub(:id) { id }
+      env[:machine] = machine
+      env[:machine].stub(:config) { config }
+      env[:machine].stub(:provider_config) { config }
+      communicate.stub(:ready?) { true }
+      env[:machine].stub(:communicate) { communicate }
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    context 'when vps_to_clone option is not set' do
+      it 'reinstall the server using instantiation_options' do
+        # env.stub(:interrupted) { false }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].communicate).to receive(:ready?)
+        expect(env[:machine].config.ssh).to receive(:username=).with(ssh.username)
+        expect(env[:rimu_api].servers).to receive(:reinstall).with(
+          id.to_i,
+          {
+            :instantiation_options=> {
+                                      :domain_name=>config.host_name,
+                                      :password=>nil,
+                                      :distro=>nil,
+                                      :control_panel=>nil
+                                      },
+            :is_just_minimal_init=>nil,
+            :vps_parameters=>{
+                              :disk_space_mb=>nil,
+                              :memory_mb=>nil,
+                              :disk_space_2_mb=>nil
+                            }
+          }
+        )
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::Rebuild.new(app, env)
+        @action.call(env)
+      end
+    end
+
+    context 'when vps_to_clone option is set' do
+      it 'reinstall the server using instantiation_via_clone_options' do
+        vps_clone = 9999
+        # env.stub(:interrupted) { false }
+        env[:machine].provider_config.stub(:vps_to_clone) { vps_clone }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].communicate).to receive(:ready?)
+        expect(env[:machine].config.ssh).to receive(:username=).with(ssh.username)
+        expect(env[:rimu_api].servers).to receive(:reinstall).with(
+          id.to_i,
+          {
+            :instantiation_via_clone_options=> {
+                                      :domain_name=>config.host_name,
+                                      :vps_order_oid_to_clone => vps_clone,
+                                      },
+            :is_just_minimal_init=>nil,
+            :vps_parameters=>{
+                              :disk_space_mb=>nil,
+                              :memory_mb=>nil,
+                              :disk_space_2_mb=>nil
+                            }
+          }
+        )
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::Rebuild.new(app, env)
+        @action.call(env)
+      end
+
+      # it 'raise an exception if ssh not ready' do
+      #   vps_clone = 9999
+      #   env.stub(:interrupted) { nil }
+      #   env[:machine].communicate.stub(:ready?) { false }
+      #   env[:machine].provider_config.stub(:vps_to_clone) { vps_clone }
+      #   expect(env[:machine].provider_config).to receive(:setup?)
+      #   expect(env[:machine].communicate).to receive(:ready?)
+      #   # expect(env[:machine].config.ssh).to receive(:username=).with(ssh.username)
+      #   expect(env[:rimu_api].servers).to receive(:reinstall).with(
+      #     id.to_i,
+      #     {
+      #       :instantiation_via_clone_options=> {
+      #                                 :domain_name=>config.host_name,
+      #                                 :vps_order_oid_to_clone => vps_clone,
+      #                                 },
+      #       :is_just_minimal_init=>nil,
+      #       :vps_parameters=>{
+      #                         :disk_space_mb=>nil,
+      #                         :memory_mb=>nil,
+      #                         :disk_space_2_mb=>nil
+      #                       }
+      #     }
+      #   )
+      #   expect(app).not_to receive(:call)
+      #   @action = VagrantPlugins::Rimu::Actions::Rebuild.new(app, env)
+      #   lambda { @action.call(env) }.should raise_error
+      # end
+    end
+  end
+end

data/spec/vagrant-rimu/actions/reload_spec.rb

@@ -0,0 +1,42 @@
+require 'pathname'
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StopInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::Reload do
+  let(:servers) { double('servers') }
+  let(:reboot) { double('reboot') }
+  let(:machine) { double('machine') }
+  let(:id) { '200' }
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        servers.stub(:reboot) { reboot }
+        os.stub(:servers) { servers }
+      end
+      machine.stub(:id) { id }
+      env[:machine] = machine
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    it 'restarts the server' do
+      expect(env[:rimu_api].servers).to receive(:reboot).with(id.to_i)
+      expect(app).to receive(:call)
+      @action = VagrantPlugins::Rimu::Actions::Reload.new(app, env)
+      @action.call(env)
+    end
+  end
+end

data/spec/vagrant-rimu/actions/setup_sudo_spec.rb

@@ -0,0 +1,94 @@
+require 'pathname'
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StopInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::SetupSudo do
+  let(:ssh) { double('ssh') }
+  let(:guest) { double('guest') }
+  let(:machine) { double('machine') }
+  let(:execute) { double('execute') }
+  let(:communicate) { double('communicate') }
+
+  let(:config) do
+    double.tap do |config|
+      config.stub(:api_url) { nil }
+      config.stub(:api_key) { 'foo' }
+      ssh.stub(:username) { 'rimu' }
+      ssh.stub(:username=) { 'rimu' }
+      ssh.stub(:private_key_path) { 'test/test_rimu_id_rsa' }
+      config.stub(:ssh) { ssh }
+    end
+  end
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      communicate.stub(:execute) { execute }
+      env[:machine] = machine
+      guest.stub(:name) { 'redhat' }
+      guest.stub(:respond_to?).with(:name) { true }
+      env[:machine].stub(:guest) { guest }
+      env[:machine].stub(:config) { config }
+      env[:machine].stub(:communicate) { communicate }
+      env[:machine].stub(:provider_config) { config }
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    user = 'rimu'
+    context 'when guest name is set to redhat' do
+      it 'setup sudo' do
+        env[:machine].provider_config.stub(:setup?) { true }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].config.ssh).to receive(:username=).with('root')
+        expect(env[:machine].guest).to receive(:respond_to?).with(:name)
+        expect(env[:machine].communicate).to receive(:execute)
+        expect(env[:machine].config.ssh).to receive(:username=).with(user)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::SetupSudo.new(app, env)
+        @action.call(env)
+      end
+    end
+
+    context 'when guest name is not set to redhat' do
+      it 'do nothing' do
+        env[:machine].provider_config.stub(:setup?) { true }
+        env[:machine].guest.stub(:name) { 'debian' }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].config.ssh).to receive(:username=).with('root')
+        expect(env[:machine].guest).to receive(:respond_to?).with(:name)
+        expect(env[:machine].communicate).not_to receive(:execute)
+        expect(env[:machine].config.ssh).to receive(:username=).with(user)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::SetupSudo.new(app, env)
+        @action.call(env)
+      end
+    end
+
+    context 'when setup is not enabled' do
+      it 'do nothing' do
+        env[:machine].provider_config.stub(:setup?) { false }
+        env[:machine].guest.stub(:name) { 'debian' }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].config.ssh).not_to receive(:username=).with('root')
+        expect(env[:machine].guest).not_to receive(:respond_to?).with(:name)
+        expect(env[:machine].communicate).not_to receive(:execute)
+        expect(env[:machine].config.ssh).not_to receive(:username=).with(user)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::SetupSudo.new(app, env)
+        @action.call(env)
+      end
+    end
+  end
+end

data/spec/vagrant-rimu/actions/setup_user_spec.rb

@@ -0,0 +1,78 @@
+require 'pathname'
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StopInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::SetupUser do
+  let(:ssh) { double('ssh') }
+  let(:m_env) { double('m_env') }
+  let(:machine) { double('machine') }
+  let(:execute) { double('execute') }
+  let(:communicate) { double('communicate') }
+
+  let(:config) do
+    double.tap do |config|
+      config.stub(:api_url) { nil }
+      config.stub(:api_key) { 'foo' }
+      ssh.stub(:username) { 'rimu' }
+      ssh.stub(:username=) { 'rimu' }
+      ssh.stub(:private_key_path) { 'test/test_rimu_id_rsa' }
+      config.stub(:ssh) { ssh }
+    end
+  end
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      communicate.stub(:execute) { execute }
+      env[:machine] = machine
+      m_env.stub(:root_path) { '.' }
+      env[:machine].stub(:env) { m_env }
+      env[:machine].stub(:config) { config }
+      env[:machine].stub(:communicate) { communicate }
+      env[:machine].stub(:provider_config) { config }
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    user = 'rimu'
+    context 'when setup is enabled' do
+      it 'setup user' do
+        env[:machine].provider_config.stub(:setup?) { true }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].config.ssh).to receive(:username)
+        expect(env[:machine].config.ssh).to receive(:username=).with('root')
+        expect(env[:machine].communicate).to receive(:execute)
+        expect(env[:machine].config.ssh).to receive(:private_key_path)
+        expect(env[:machine].config.ssh).to receive(:username=).with(user)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::SetupUser.new(app, env)
+        @action.call(env)
+      end
+    end
+    context 'when setup is not enabled' do
+      it 'do nothing' do
+        env[:machine].provider_config.stub(:setup?) { false }
+        expect(env[:machine].provider_config).to receive(:setup?)
+        expect(env[:machine].config.ssh).not_to receive(:username)
+        expect(env[:machine].config.ssh).not_to receive(:username=).with('root')
+        expect(env[:machine].communicate).not_to receive(:execute)
+        expect(env[:machine].config.ssh).not_to receive(:private_key_path)
+        expect(env[:machine].config.ssh).not_to receive(:username=).with(user)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::SetupUser.new(app, env)
+        @action.call(env)
+      end
+    end
+  end
+end

data/spec/vagrant-rimu/actions/start_instance_spec.rb

@@ -0,0 +1,64 @@
+require 'pathname'
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StartInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::StartInstance do
+  let(:servers) { double('servers') }
+  let(:start) { double('start') }
+  let(:machine) { double('machine') }
+  let(:id) { '200' }
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      machine.stub(:id) { id }
+      env[:machine] = machine
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    it 'starts server' do
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        start.stub(:running_state) { 'RUNNING' }
+        servers.stub(:start) { start }
+        os.stub(:servers) { servers }
+      end
+      expect(env[:rimu_api].servers).to receive(:start).with(id.to_i)
+      expect(app).to receive(:call)
+      @action = VagrantPlugins::Rimu::Actions::StartInstance.new(app, env)
+      @action.call(env)
+    end
+
+    it 'raises exception if api does not respond' do
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        servers.stub(:start) { nil }
+        os.stub(:servers) { servers }
+      end
+      expect(env[:rimu_api].servers).to receive(:start).with(id.to_i)
+      @action = VagrantPlugins::Rimu::Actions::StartInstance.new(app, env)
+      lambda { @action.call(env) }.should raise_error(VagrantPlugins::Rimu::Errors::ApiError)
+    end
+
+    it 'raises exception if server does not start' do
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        start.stub(:running_state) { 'NOTRUNNING' }
+        servers.stub(:start) { start }
+        os.stub(:servers) { servers }
+      end
+      expect(env[:rimu_api].servers).to receive(:start).with(id.to_i)
+      @action = VagrantPlugins::Rimu::Actions::StartInstance.new(app, env)
+      lambda { @action.call(env) }.should raise_error(VagrantPlugins::Rimu::Errors::ApiError)
+    end
+  end
+end

data/spec/vagrant-rimu/actions/stop_instance_spec.rb

@@ -0,0 +1,57 @@
+require 'pathname'
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StopInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::StopInstance do
+  let(:servers) { double('servers') }
+  let(:shutdown) { double('shutdown') }
+  let(:machine) { double('machine') }
+  let(:state) { double('state') }
+  let(:id) { '200' }
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        servers.stub(:shutdown) { shutdown }
+        os.stub(:servers) { servers }
+      end
+      machine.stub(:id) { id }
+      env[:machine] = machine
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    context 'when server state id is not :stopped' do
+      it 'stops the server' do
+        state.stub(:id) { :running }
+        env[:machine].stub(:state) { state }
+        expect(env[:rimu_api].servers).to receive(:shutdown).with(id.to_i)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::StopInstance.new(app, env)
+        @action.call(env)
+      end
+    end
+    context 'when server id is :stopped' do
+      it 'does nothing' do
+        state.stub(:id) { :stopped }
+        env[:machine].stub(:state) { state }
+        expect(env[:rimu_api].servers).to_not receive(:shutdown)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::StopInstance.new(app, env)
+        @action.call(env)
+      end
+    end
+  end
+end

data/spec/vagrant-rimu/actions/terminate_instance_spec.rb

@@ -0,0 +1,54 @@
+require 'ostruct'
+require 'pathname'
+
+require 'spec_helper'
+
+# action_root = Pathname.new(File.expand_path('../../../../lib/vagrant-rimu/actions', __FILE__))
+# autoload :StopInstance, action_root.join('stop_instance')
+
+describe VagrantPlugins::Rimu::Actions::TerminateInstance do
+  let(:servers) { double('servers') }
+  let(:cancel) { double('cancel') }
+
+  let(:env) do
+    {}.tap do |env|
+      env[:ui] = double('ui').tap do |ui|
+        ui.stub(:info).with(anything)
+        ui.stub(:error).with(anything)
+      end
+      env[:rimu_api] = double('rimu_api').tap do |os|
+        servers.stub(:cancel) { cancel }
+        os.stub(:servers) { servers }
+      end
+      env[:machine] = OpenStruct.new
+    end
+  end
+
+  let(:app) do
+    double('app').tap do |app|
+      app.stub(:call).with(anything)
+    end
+  end
+
+  describe 'call' do
+    context 'when server id is set' do
+      it 'terminates the server' do
+        id = '200'
+        env[:machine].id = id
+        expect(env[:rimu_api].servers).to receive(:cancel).with(id.to_i)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::TerminateInstance.new(app, env)
+        @action.call(env)
+      end
+    end
+    context 'when server id is not set' do
+      it 'do nothing' do
+        env[:machine].id = nil
+        expect(env[:rimu_api].servers).to_not receive(:cancel)
+        expect(app).to receive(:call)
+        @action = VagrantPlugins::Rimu::Actions::TerminateInstance.new(app, env)
+        @action.call(env)
+      end
+    end
+  end
+end

data/spec/vagrant-rimu/actions_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Actions do
+  let(:builder) do
+    double('builder').tap do |builder|
+      builder.stub(:use)
+    end
+  end
+
+  # before :each do
+  #   Actions.stub(:new_builder) { builder }
+  # end
+  #
+  # describe 'action_destroy' do
+  #   it 'add others middleware to builder' do
+  #     expect(builder).to receive(:use).with(ConfigValidate)
+  #     expect(builder).to receive(:use).with(ConnectToRimu)
+  #     expect(builder).to receive(:use).with(Call, ReadState)
+  #     Actions.action_destroy
+  #   end
+  # end
+end

data/spec/vagrant-rimu/commands/billing_methods_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Commands::BillingMethods do
+end

data/spec/vagrant-rimu/commands/distributions_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Commands::Distributions do
+end

data/spec/vagrant-rimu/commands/list_servers_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Commands::ListServers do
+end

data/spec/vagrant-rimu/commands/move_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Commands::Move do
+end

data/spec/vagrant-rimu/commands/rebuild_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Commands::Rebuild do
+end

data/spec/vagrant-rimu/commands/root_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe VagrantPlugins::Rimu::Commands::Root do
+end