jisota 0.0.1 → 0.0.2

data/spec/lib/jisota/output_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+module Jisota
+  describe Output do
+    let(:logger) { Output.new(stdout: stdout, stderr: stderr, verbose: verbose) }
+    let(:stdout) { instance_double(IO, write: nil, flush: nil) }
+    let(:stderr) { instance_double(IO, write: nil, flush: nil) }
+    let(:verbose) { true }
+
+    describe "initialization" do
+      it "initializes with options" do
+        logger = Output.new(stdout: :out, stderr: :err, verbose: false)
+        expect(logger.stdout).to eq(:out)
+        expect(logger.stderr).to eq(:err)
+        expect(logger.verbose).to be false
+      end
+    end
+
+    describe '#info' do
+      it "writes to stdout" do
+        logger.info("foo")
+        expect(stdout).to have_received(:write).with("foo")
+      end
+    end
+
+    describe "#error" do
+      it "writes to stderr" do
+        logger.error("foo")
+        expect(stderr).to have_received(:write).with("foo")
+      end
+    end
+
+    describe "#warn" do
+      context "verbose" do
+        let(:verbose) { true }
+        it "outputs" do
+          logger.warn("foo")
+          expect(stderr).to have_received(:write).with("foo")
+        end
+      end
+
+      context "not verbose" do
+        let(:verbose) { false }
+        it "outputs" do
+          logger.warn("foo")
+          expect(stderr).to_not have_received(:write).with("foo")
+        end
+      end
+    end
+
+    describe "#system_message" do
+      it "outputs message" do
+        logger.system_message("foo")
+        expect(stdout).to have_received(:write).with("-----> foo\n")
+      end
+    end
+
+    describe "#indent" do
+      it "indents subsequent output" do
+        logger.indent
+        logger.system_message("foo")
+        expect(stdout).to have_received(:write).with("----->   foo\n")
+
+        logger.outdent
+        logger.system_message("foo")
+        expect(stdout).to have_received(:write).with("-----> foo\n")
+      end
+
+      context "with a block" do
+        it "indents logs inside block" do
+          result = logger.indent do
+            logger.system_message("foo")
+            42
+          end
+          logger.system_message("bar")
+          expect(stdout).to have_received(:write).with("----->   foo\n")
+          expect(stdout).to have_received(:write).with("-----> bar\n")
+          expect(result).to eq(42)
+        end
+      end
+    end
+
+  end
+end

data/spec/lib/jisota/package_script_spec.rb

@@ -3,17 +3,18 @@ require 'spec_helper'
 module Jisota
   describe PackageScript do
     describe "#execute" do
-      let(:ssh_session) { instance_double(SSHSession, command: true) }
+      let(:ssh_session) { instance_double(SSHSession, command: 0) }
+      let(:context) { ScriptContext.new(ssh_session: ssh_session) }
 
       it "executes each script from the block" do
         package = Package.new do
           run { cmd "foo" }
         end
         package_script = PackageScript.new(package)
-        result = package_script.execute(ssh_session)
+        result = package_script.execute(context)
 
         expect(result).to be true
-        expect(ssh_session).to have_received(:command).with("foo", nil)
+        expect(ssh_session).to have_received(:command).with("foo", anything)
       end
 
       it "parses args" do
@@ -22,9 +23,9 @@ module Jisota
           run { cmd "foo #{bar}" }
         end
         package_script = PackageScript.new(package, ["baz"])
-        package_script.execute(ssh_session)
+        package_script.execute(context)
 
-        expect(ssh_session).to have_received(:command).with("foo baz", nil)
+        expect(ssh_session).to have_received(:command).with("foo baz", anything)
       end
 
       it "uses verify block" do
@@ -33,10 +34,21 @@ module Jisota
           verify { cmd "bar" }
         end
         package_script = PackageScript.new(package)
-        package_script.execute(ssh_session)
+        package_script.execute(context)
 
-        expect(ssh_session).to have_received(:command).with("bar", nil)
-        expect(ssh_session).to_not have_received(:command).with("foo", nil)
+        expect(ssh_session).to have_received(:command).with("bar", anything)
+        expect(ssh_session).to_not have_received(:command).with("foo", anything)
+      end
+    end
+
+    describe "#to_s" do
+      it "outputs a nice representation of the script" do
+        package = Package.new(:nginx)
+
+        expect(PackageScript.new(package, []).to_s).to eq("nginx")
+        expect(PackageScript.new(package, ["foo"]).to_s).to eq('nginx "foo"')
+        expect(PackageScript.new(package, ["foo", 42]).to_s).to eq('nginx "foo", 42')
+        expect(PackageScript.new(package, [{ foo: 42 }]).to_s).to eq("nginx {:foo=>42}")
       end
     end
   end

data/spec/lib/jisota/package_spec.rb

@@ -53,12 +53,8 @@ module Jisota
           description "Does cool stuff"
           param :foo
           param :bar, default: 42
-          run do
-            cmd "touch #{foo}"
-          end
-          verify do
-            cmd "[ -f foo ]"
-          end
+          run { cmd "touch #{foo}" }
+          verify { cmd "[ -f foo ]" }
         end
 
         expect(package.name).to eq(:my_awesome_package)

data/spec/lib/jisota/packages/apt_spec.rb

@@ -2,14 +2,17 @@
 require 'spec_helper'
 
 module Jisota
-  describe "Ruby package" do
+  describe "Apt package" do
     it "is valid" do
       script_block = ScriptBlock.new do
         apt :curl
       end
-      script = script_block.evaluate({}, Jisota.global_packages)
-      ssh_session = instance_double(SSHSession, command: true, upload: true)
-      expect { script.execute(ssh_session) }.to_not raise_exception
+      ssh_session = instance_double(SSHSession, upload: true)
+      allow(ssh_session).to receive(:command).and_return(false, true)
+      context = ScriptContext.new(ssh_session: ssh_session, packages: Jisota.global_packages)
+      script = script_block.evaluate(context)
+
+      expect { script.execute(context) }.to_not raise_exception
     end
   end
 end

data/spec/lib/jisota/packages/gem_install_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+module Jisota
+  describe "Gem-install package" do
+    it "is valid" do
+      script_block = ScriptBlock.new do
+        gem_install :foo
+      end
+      ssh_session = instance_double(SSHSession)
+      allow(ssh_session).to receive(:command).and_return(1, 0)
+      context = ScriptContext.new(ssh_session: ssh_session, packages: Jisota.global_packages)
+      script = script_block.evaluate(context)
+
+      expect { script.execute(context) }.to_not raise_exception
+    end
+  end
+end
+

data/spec/lib/jisota/packages/nginx_passenger_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Jisota
+  describe "Nginx Passenger package" do
+    it "is valid" do
+      script_block = ScriptBlock.new do
+        nginx_passenger config_file: "foo"
+      end
+      ssh_session = instance_double(SSHSession, upload: true, command: 0)
+      context = ScriptContext.new(ssh_session: ssh_session, packages: Jisota.global_packages)
+      script = script_block.evaluate(context)
+
+      expect { script.execute(context) }.to_not raise_exception
+    end
+  end
+end
+

data/spec/lib/jisota/packages/ruby_spec.rb

@@ -6,9 +6,12 @@ module Jisota
       script_block = ScriptBlock.new do
         ruby version: "2.1.1"
       end
-      script = script_block.evaluate({}, Jisota.global_packages)
-      ssh_session = instance_double(SSHSession, command: true, upload: true)
-      expect { script.execute(ssh_session) }.to_not raise_exception
+      ssh_session = instance_double(SSHSession, upload: true)
+      allow(ssh_session).to receive(:command).and_return(false, true)
+      context = ScriptContext.new(ssh_session: ssh_session, packages: Jisota.global_packages)
+      script = script_block.evaluate(context)
+
+      expect { script.execute(context) }.to_not raise_exception
     end
   end
 end

data/spec/lib/jisota/param_parser_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Jisota::ParamParser do
+  subject { parser.parse() }
+  let(:parser) { Jisota::ParamParser.new(params, args) }
+  let(:params) { [] }
+  let(:args) { [] }
+
+  def should_raise(error)
+    expect { subject }.to raise_exception(error)
+  end
+
+  context "no params" do
+    context "no args" do
+      it { should eq Hash.new }
+    end
+
+    context "implicit arg" do
+      let(:args) { [42] }
+      it { should_raise(Jisota::ParameterError) }
+    end
+
+    context "hash arg" do
+      let(:args) { [ { foo: 42 } ] }
+      it { should_raise(Jisota::ParameterError) }
+    end
+  end
+
+  context "param with no options" do
+    let(:params) { [Jisota::Param.new(:foo)] }
+
+    context "no args" do
+      it { should eq({foo: nil}) }
+    end
+
+    context "implicit arg" do
+      let(:args) { [42] }
+      it { should eq({foo: 42}) }
+    end
+
+    context "repeated implicit arg" do
+      let(:args) { [42, { foo: 42 }] }
+      it { should_raise(Jisota::ParameterError) }
+    end
+
+    context "hash arg" do
+      let(:args) { [ { foo: 42 } ] }
+      it { should eq({foo: 42}) }
+    end
+  end
+
+  context "param with required: true" do
+    let(:params) { [Jisota::Param.new(:foo, required: true)] }
+
+    context "no args" do
+      it { should_raise(Jisota::ParameterError) }
+    end
+
+    context "implicit arg" do
+      let(:args) { [42] }
+      it { should eq({foo: 42}) }
+    end
+
+    context "hash arg" do
+      let(:args) { [ { foo: 42 } ] }
+      it { should eq({foo: 42}) }
+    end
+  end
+
+  context "param with default" do
+    let(:params) { [Jisota::Param.new(:foo, default: 48)] }
+
+    context "no args" do
+      it { should eq({foo: 48}) }
+    end
+
+    context "implicit arg" do
+      let(:args) { [42] }
+      it { should eq({foo: 42}) }
+    end
+
+    context "hash arg" do
+      let(:args) { [ { foo: 42 } ] }
+      it { should eq({foo: 42}) }
+    end
+  end
+
+  context "param with splat: true" do
+    let(:params) { [Jisota::Param.new(:foo, splat: true)] }
+
+    context "no args" do
+      it { should eq({foo: []}) }
+    end
+
+    context "implicit arg" do
+      let(:args) { [42] }
+      it { should eq({foo: [42]}) }
+    end
+
+    context "hash arg" do
+      let(:args) { [ { foo: 42 } ] }
+      it { should_raise(Jisota::ParameterError) }
+    end
+  end
+end

data/spec/lib/jisota/provisioner_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+module Jisota
+  describe Provisioner do
+    describe "#run" do
+
+      let(:ssh_engine) do
+        instance_double(SSHEngine).tap do |ssh|
+          allow(ssh).to receive(:start).with({user: "john", host: "123.456.789.0"}).and_yield(ssh_session)
+        end
+      end
+      let(:ssh_session) { instance_double(SSHSession, command: 0) }
+
+      it "executes a script" do
+        config = Configuration.new do
+          role :app do
+            cmd "touch foo"
+          end
+          server "123.456.789.0", user: "john", roles: :app
+        end
+        config.ssh_engine = ssh_engine
+
+        provisioner = Provisioner.new
+        provisioner.run(config, NilOutput.new)
+
+        expect(ssh_session).to have_received(:command).with("touch foo", anything)
+      end
+    end
+  end
+end

data/spec/lib/jisota/role_spec.rb

@@ -20,9 +20,7 @@ module Jisota
 
     describe "DSL" do
       it "initializes with DSL" do
-        role = Role.new(:app) do
-          cmd "touch foo"
-        end
+        role = Role.new(:app) { cmd "touch foo" }
         expect(role.name).to eq(:app)
         expect(role.script_block).to be_a(ScriptBlock)
       end

data/spec/lib/jisota/script_block_spec.rb

@@ -23,13 +23,15 @@ module Jisota
         expect(script.scripts[0]).to be_a(CommandScript)
         expect(script.scripts[0].command).to eq("foo")
         expect(script.scripts[1]).to be_a(FileScript)
-        expect(script.scripts[1].file).to eq(UploadFile.new("x", "y"))
+        expect(script.scripts[1].from).to eq("x")
+        expect(script.scripts[1].to).to eq("y")
       end
 
       it "parses args" do
         script_block = ScriptBlock.new { cmd "touch #{foo}" }
-        args = { foo: "bar" }
-        script = script_block.evaluate(args)
+        params = { foo: "bar" }
+        context = ScriptContext.new(params: params)
+        script = script_block.evaluate(context)
 
         expect(script.scripts.first.command).to eq("touch bar")
       end
@@ -38,8 +40,9 @@ module Jisota
         script_block = ScriptBlock.new { touch "file" }
         packages = Collection.new
         packages << Package.new(:touch)
+        context = ScriptContext.new(packages: packages)
 
-        script = script_block.evaluate({}, packages)
+        script = script_block.evaluate(context)
         script = script.scripts.first
 
         expect(script).to be_a(PackageScript)

data/spec/lib/jisota/ssh_engine_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module Jisota
+  describe SSHEngine do
+    describe "#start" do
+      let(:engine) do
+        class_double(Net::SSH).tap do |engine|
+          allow(engine).to receive(:start).and_yield(nil)
+        end
+      end
+      let(:wrapper) { SSHEngine.new(engine: engine) }
+
+      it "starts the engine" do
+        wrapper.start(user: "john", host: "foo") { |ssh_session| }
+
+        expect(engine).to have_received(:start).with("foo", "john", {})
+      end
+
+      it "passes extra options to engine" do
+        wrapper.start(user: "john", host: "foo", foo: "bar", bar: "baz") { |ssh_session| }
+
+        expect(engine).to have_received(:start).with("foo", "john", { foo: "bar", bar: "baz" })
+      end
+    end
+  end
+end