capistrano 2.8.0 → 3.19.0

data/spec/lib/capistrano/configuration/server_spec.rb

@@ -0,0 +1,309 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe Server do
+      let(:server) { Server.new("root@hostname:1234") }
+
+      describe "adding a role" do
+        subject { server.add_role(:test) }
+        it "adds the role" do
+          expect { subject }.to change { server.roles.size }.from(0).to(1)
+        end
+      end
+
+      describe "adding roles" do
+        subject { server.add_roles(%i(things stuff)) }
+        it "adds the roles" do
+          expect { subject }.to change { server.roles.size }.from(0).to(2)
+        end
+      end
+
+      describe "checking roles" do
+        subject { server.has_role?(:test) }
+
+        before do
+          server.add_role(:test)
+        end
+
+        it "adds the role" do
+          expect(subject).to be_truthy
+        end
+      end
+
+      describe "comparing identity" do
+        subject { server.hostname == Server[hostname].hostname }
+
+        context "with the same user, hostname and port" do
+          let(:hostname) { "root@hostname:1234" }
+          it { expect(subject).to be_truthy }
+        end
+
+        context "with a different user" do
+          let(:hostname) { "deployer@hostname:1234" }
+          it { expect(subject).to be_truthy }
+        end
+
+        context "with a different port" do
+          let(:hostname) { "root@hostname:5678" }
+          it { expect(subject).to be_truthy }
+        end
+
+        context "with a different hostname" do
+          let(:hostname) { "root@otherserver:1234" }
+          it { expect(subject).to be_falsey }
+        end
+      end
+
+      describe "identifying as primary" do
+        subject { server.primary }
+        context "server is primary" do
+          before do
+            server.set(:primary, true)
+          end
+          it "returns self" do
+            expect(subject).to eq server
+          end
+        end
+
+        context "server is not primary" do
+          it "is falesy" do
+            expect(subject).to be_falsey
+          end
+        end
+      end
+
+      describe "assigning properties" do
+        before do
+          server.with(properties)
+        end
+
+        context "properties contains roles" do
+          let(:properties) { { roles: [:clouds] } }
+
+          it "adds the roles" do
+            expect(server.roles.first).to eq :clouds
+          end
+        end
+
+        context "properties contains user" do
+          let(:properties) { { user: "tomc" } }
+
+          it "sets the user" do
+            expect(server.user).to eq "tomc"
+          end
+
+          it "sets the netssh_options user" do
+            expect(server.netssh_options[:user]).to eq "tomc"
+          end
+        end
+
+        context "properties contains port" do
+          let(:properties) { { port: 2222 } }
+
+          it "sets the port" do
+            expect(server.port).to eq 2222
+          end
+        end
+
+        context "properties contains key" do
+          let(:properties) { { key: "/key" } }
+
+          it "adds the key" do
+            expect(server.keys).to include "/key"
+          end
+        end
+
+        context "properties contains password" do
+          let(:properties) { { password: "supersecret" } }
+
+          it "adds the key" do
+            expect(server.password).to eq "supersecret"
+          end
+        end
+
+        context "new properties" do
+          let(:properties) { { webscales: 5 } }
+
+          it "adds the properties" do
+            expect(server.properties.webscales).to eq 5
+          end
+        end
+
+        context "existing properties" do
+          let(:properties) { { webscales: 6 } }
+
+          it "keeps the existing properties" do
+            expect(server.properties.webscales).to eq 6
+            server.properties.webscales = 5
+            expect(server.properties.webscales).to eq 5
+          end
+        end
+      end
+
+      describe "#include?" do
+        let(:options) { {} }
+
+        subject { server.select?(options) }
+
+        before do
+          server.properties.active = true
+        end
+
+        context "options are empty" do
+          it { expect(subject).to be_truthy }
+        end
+
+        context "value is a symbol" do
+          context "value matches server property" do
+            context "with :filter" do
+              let(:options) { { filter: :active } }
+              it { expect(subject).to be_truthy }
+            end
+
+            context "with :select" do
+              let(:options) { { select: :active } }
+              it { expect(subject).to be_truthy }
+            end
+
+            context "with :exclude" do
+              let(:options) { { exclude: :active } }
+              it { expect(subject).to be_falsey }
+            end
+          end
+
+          context "value does not match server properly" do
+            context "with :active true" do
+              let(:options) { { active: true } }
+              it { expect(subject).to be_truthy }
+            end
+
+            context "with :active false" do
+              let(:options) { { active: false } }
+              it { expect(subject).to be_falsey }
+            end
+          end
+
+          context "value does not match server properly" do
+            context "with :filter" do
+              let(:options) { { filter: :inactive } }
+              it { expect(subject).to be_falsey }
+            end
+
+            context "with :select" do
+              let(:options) { { select: :inactive } }
+              it { expect(subject).to be_falsey }
+            end
+
+            context "with :exclude" do
+              let(:options) { { exclude: :inactive } }
+              it { expect(subject).to be_truthy }
+            end
+          end
+        end
+
+        context "key is a property" do
+          context "with :active true" do
+            let(:options) { { active: true } }
+            it { expect(subject).to be_truthy }
+          end
+
+          context "with :active false" do
+            let(:options) { { active: false } }
+            it { expect(subject).to be_falsey }
+          end
+        end
+
+        context "value is a proc" do
+          context "value matches server property" do
+            context "with :filter" do
+              let(:options) { { filter: ->(s) { s.properties.active } } }
+              it { expect(subject).to be_truthy }
+            end
+
+            context "with :select" do
+              let(:options) { { select: ->(s) { s.properties.active } } }
+              it { expect(subject).to be_truthy }
+            end
+
+            context "with :exclude" do
+              let(:options) { { exclude: ->(s) { s.properties.active } } }
+              it { expect(subject).to be_falsey }
+            end
+          end
+
+          context "value does not match server properly" do
+            context "with :filter" do
+              let(:options) { { filter: ->(s) { s.properties.inactive } } }
+              it { expect(subject).to be_falsey }
+            end
+
+            context "with :select" do
+              let(:options) { { select: ->(s) { s.properties.inactive } } }
+              it { expect(subject).to be_falsey }
+            end
+
+            context "with :exclude" do
+              let(:options) { { exclude: ->(s) { s.properties.inactive } } }
+              it { expect(subject).to be_truthy }
+            end
+          end
+        end
+      end
+
+      describe "assign ssh_options" do
+        let(:server) { Server.new("user_name@hostname") }
+
+        context "defaults" do
+          it "forward agent" do
+            expect(server.netssh_options[:forward_agent]).to eq true
+          end
+          it "contains user" do
+            expect(server.netssh_options[:user]).to eq "user_name"
+          end
+        end
+
+        context "custom" do
+          let(:properties) do
+            { ssh_options: {
+              user: "another_user",
+              keys: %w(/home/another_user/.ssh/id_rsa),
+              forward_agent: false,
+              auth_methods: %w(publickey password)
+            } }
+          end
+
+          before do
+            server.with(properties)
+          end
+
+          it "not forward agent" do
+            expect(server.netssh_options[:forward_agent]).to eq false
+          end
+          it "contains correct user" do
+            expect(server.netssh_options[:user]).to eq "another_user"
+          end
+          it "does not affect server user in host" do
+            expect(server.user).to eq "user_name"
+          end
+          it "contains keys" do
+            expect(server.netssh_options[:keys]).to eq %w(/home/another_user/.ssh/id_rsa)
+          end
+          it "contains auth_methods" do
+            expect(server.netssh_options[:auth_methods]).to eq %w(publickey password)
+          end
+        end
+      end
+
+      describe ".[]" do
+        it "creates a server if its argument is not already a server" do
+          expect(Server["hostname:1234"]).to be_a Server
+        end
+
+        it "returns its argument if it is already a server" do
+          expect(Server[server]).to be server
+        end
+      end
+    end
+  end
+end

data/spec/lib/capistrano/configuration/servers_spec.rb

@@ -0,0 +1,331 @@
+require "spec_helper"
+
+module Capistrano
+  class Configuration
+    describe Servers do
+      let(:servers) { Servers.new }
+
+      describe "adding a role" do
+        it "adds two new server instances" do
+          expect { servers.add_role(:app, %w{1 2}) }
+            .to change { servers.count }.from(0).to(2)
+        end
+
+        it "handles de-duplification within roles" do
+          servers.add_role(:app, %w{1})
+          servers.add_role(:app, %w{1})
+          expect(servers.count).to eq 1
+        end
+
+        it "handles de-duplification within roles with users" do
+          servers.add_role(:app, %w{1}, user: "nick")
+          servers.add_role(:app, %w{1}, user: "fred")
+          expect(servers.count).to eq 1
+        end
+
+        it "accepts instances of server objects" do
+          servers.add_role(:app, [Capistrano::Configuration::Server.new("example.net"), "example.com"])
+          expect(servers.roles_for([:app]).length).to eq 2
+        end
+
+        it "accepts non-enumerable types" do
+          servers.add_role(:app, "1")
+          expect(servers.roles_for([:app]).count).to eq 1
+        end
+
+        it "creates distinct server properties" do
+          servers.add_role(:db, %w{1 2}, db: { port: 1234 })
+          servers.add_host("1", db: { master: true })
+          expect(servers.count).to eq(2)
+          expect(servers.roles_for([:db]).count).to eq 2
+          expect(servers.find { |s| s.hostname == "1" }.properties.db).to eq(port: 1234, master: true)
+          expect(servers.find { |s| s.hostname == "2" }.properties.db).to eq(port: 1234)
+        end
+      end
+
+      describe "adding a role to an existing server" do
+        before do
+          servers.add_role(:web, %w{1 2})
+          servers.add_role(:app, %w{1 2})
+        end
+
+        it "adds new roles to existing servers" do
+          expect(servers.count).to eq 2
+        end
+      end
+
+      describe "collecting server roles" do
+        let(:app) { Set.new([:app]) }
+        let(:web_app) { Set.new(%i(web app)) }
+        let(:web) { Set.new([:web]) }
+
+        before do
+          servers.add_role(:app, %w{1 2 3})
+          servers.add_role(:web, %w{2 3 4})
+        end
+
+        it "returns an array of the roles" do
+          expect(servers.roles_for([:app]).collect(&:roles)).to eq [app, web_app, web_app]
+          expect(servers.roles_for([:web]).collect(&:roles)).to eq [web_app, web_app, web]
+        end
+      end
+
+      describe "finding the primary server" do
+        after do
+          Configuration.reset!
+        end
+        it "takes the first server if none have the primary property" do
+          servers.add_role(:app, %w{1 2})
+          expect(servers.fetch_primary(:app).hostname).to eq("1")
+        end
+
+        it "takes the first server with the primary have the primary flag" do
+          servers.add_role(:app, %w{1 2})
+          servers.add_host("2", primary: true)
+          expect(servers.fetch_primary(:app).hostname).to eq("2")
+        end
+
+        it "ignores any on_filters" do
+          Configuration.env.set :filter, host: "1"
+          servers.add_role(:app, %w{1 2})
+          servers.add_host("2", primary: true)
+          expect(servers.fetch_primary(:app).hostname).to eq("2")
+        end
+      end
+
+      describe "fetching servers" do
+        before do
+          servers.add_role(:app, %w{1 2})
+          servers.add_role(:web, %w{2 3})
+        end
+
+        it "returns the correct app servers" do
+          expect(servers.roles_for([:app]).map(&:hostname)).to eq %w{1 2}
+        end
+
+        it "returns the correct web servers" do
+          expect(servers.roles_for([:web]).map(&:hostname)).to eq %w{2 3}
+        end
+
+        it "returns the correct app and web servers" do
+          expect(servers.roles_for(%i(app web)).map(&:hostname)).to eq %w{1 2 3}
+        end
+
+        it "returns all servers" do
+          expect(servers.roles_for([:all]).map(&:hostname)).to eq %w{1 2 3}
+        end
+      end
+
+      describe "adding a server" do
+        before do
+          servers.add_host("1", roles: [:app, "web"], test: :value)
+        end
+
+        it "can create a server with properties" do
+          expect(servers.roles_for([:app]).first.hostname).to eq "1"
+          expect(servers.roles_for([:web]).first.hostname).to eq "1"
+          expect(servers.roles_for([:all]).first.properties.test).to eq :value
+          expect(servers.roles_for([:all]).first.properties.keys).to eq [:test]
+        end
+
+        it "can accept multiple servers with the same hostname but different ports or users" do
+          servers.add_host("1", roles: [:app, "web"], test: :value, port: 12)
+          expect(servers.count).to eq(2)
+          servers.add_host("1", roles: [:app, "web"], test: :value, port: 34)
+          servers.add_host("1", roles: [:app, "web"], test: :value, user: "root")
+          servers.add_host("1", roles: [:app, "web"], test: :value, user: "deployer")
+          servers.add_host("1", roles: [:app, "web"], test: :value, user: "root", port: 34)
+          servers.add_host("1", roles: [:app, "web"], test: :value, user: "deployer", port: 34)
+          servers.add_host("1", roles: [:app, "web"], test: :value, user: "deployer", port: 56)
+          expect(servers.count).to eq(4)
+        end
+
+        describe "with a :user property" do
+          it "sets the server ssh username" do
+            servers.add_host("1", roles: [:app, "web"], user: "nick")
+            expect(servers.count).to eq(1)
+            expect(servers.roles_for([:all]).first.user).to eq "nick"
+          end
+
+          it "overwrites the value of a user specified in the hostname" do
+            servers.add_host("brian@1", roles: [:app, "web"], user: "nick")
+            expect(servers.count).to eq(1)
+            expect(servers.roles_for([:all]).first.user).to eq "nick"
+          end
+        end
+
+        it "overwrites the value of a previously defined scalar property" do
+          servers.add_host("1", roles: [:app, "web"], test: :volatile)
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:all]).first.properties.test).to eq :volatile
+        end
+
+        it "merges previously defined hash properties" do
+          servers.add_host("1", roles: [:b], db: { port: 1234 })
+          servers.add_host("1", roles: [:b], db: { master: true })
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:b]).first.properties.db).to eq(port: 1234, master: true)
+        end
+
+        it "concatenates previously defined array properties" do
+          servers.add_host("1", roles: [:b], steps: [1, 3, 5])
+          servers.add_host("1", roles: [:b], steps: [1, 9])
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:b]).first.properties.steps).to eq([1, 3, 5, 1, 9])
+        end
+
+        it "merges previously defined set properties" do
+          servers.add_host("1", roles: [:b], endpoints: Set[123, 333])
+          servers.add_host("1", roles: [:b], endpoints: Set[222, 333])
+          expect(servers.count).to eq(1)
+          expect(servers.roles_for([:b]).first.properties.endpoints).to eq(Set[123, 222, 333])
+        end
+
+        it "adds array property value only ones for a new host" do
+          servers.add_host("2", roles: [:array_test], array_property: [1, 2])
+          expect(servers.roles_for([:array_test]).first.properties.array_property).to eq [1, 2]
+        end
+
+        it "updates roles when custom user defined" do
+          servers.add_host("1", roles: ["foo"], user: "custom")
+          servers.add_host("1", roles: ["bar"], user: "custom")
+          expect(servers.roles_for([:foo]).first.hostname).to eq "1"
+          expect(servers.roles_for([:bar]).first.hostname).to eq "1"
+        end
+
+        it "updates roles when custom port defined" do
+          servers.add_host("1", roles: ["foo"], port: 1234)
+          servers.add_host("1", roles: ["bar"], port: 1234)
+          expect(servers.roles_for([:foo]).first.hostname).to eq "1"
+          expect(servers.roles_for([:bar]).first.hostname).to eq "1"
+        end
+      end
+
+      describe "selecting roles" do
+        before do
+          servers.add_host("1", roles: :app, active: true)
+          servers.add_host("2", roles: :app)
+        end
+
+        it "is empty if the filter would remove all matching hosts" do
+          expect(servers.roles_for([:app, select: :inactive])).to be_empty
+        end
+
+        it "can filter hosts by properties on the host object using symbol as shorthand" do
+          expect(servers.roles_for([:app, filter: :active]).length).to eq 1
+        end
+
+        it "can select hosts by properties on the host object using symbol as shorthand" do
+          expect(servers.roles_for([:app, select: :active]).length).to eq 1
+        end
+
+        it "can filter hosts by properties on the host using a regular proc" do
+          expect(servers.roles_for([:app, filter: ->(h) { h.properties.active }]).length).to eq 1
+        end
+
+        it "can select hosts by properties on the host using a regular proc" do
+          expect(servers.roles_for([:app, select: ->(h) { h.properties.active }]).length).to eq 1
+        end
+
+        it "is empty if the regular proc filter would remove all matching hosts" do
+          expect(servers.roles_for([:app, select: ->(h) { h.properties.inactive }])).to be_empty
+        end
+      end
+
+      describe "excluding by property" do
+        before do
+          servers.add_host("1", roles: :app, active: true)
+          servers.add_host("2", roles: :app, active: true, no_release: true)
+        end
+
+        it "is empty if the filter would remove all matching hosts" do
+          hosts = servers.roles_for([:app, exclude: :active])
+          expect(hosts.map(&:hostname)).to be_empty
+        end
+
+        it "returns the servers without the attributes specified" do
+          hosts = servers.roles_for([:app, exclude: :no_release])
+          expect(hosts.map(&:hostname)).to eq %w{1}
+        end
+
+        it "can exclude hosts by properties on the host using a regular proc" do
+          hosts = servers.roles_for([:app, exclude: ->(h) { h.properties.no_release }])
+          expect(hosts.map(&:hostname)).to eq %w{1}
+        end
+
+        it "is empty if the regular proc filter would remove all matching hosts" do
+          hosts = servers.roles_for([:app, exclude: ->(h) { h.properties.active }])
+          expect(hosts.map(&:hostname)).to be_empty
+        end
+      end
+
+      describe "filtering roles internally" do
+        before do
+          servers.add_host("1", roles: :app, active: true)
+          servers.add_host("2", roles: :app)
+          servers.add_host("3", roles: :web)
+          servers.add_host("4", roles: :web)
+          servers.add_host("5", roles: :db)
+        end
+
+        subject { servers.roles_for(roles).map(&:hostname) }
+
+        context "with the ROLES environment variable set" do
+          before do
+            ENV.stubs(:[]).with("ROLES").returns("web,db")
+            ENV.stubs(:[]).with("HOSTS").returns(nil)
+          end
+
+          context "when selecting all roles" do
+            let(:roles) { [:all] }
+            it "ignores it" do
+              expect(subject).to eq %w{1 2 3 4 5}
+            end
+          end
+
+          context "when selecting specific roles" do
+            let(:roles) { %i(app web) }
+            it "ignores it" do
+              expect(subject).to eq %w{1 2 3 4}
+            end
+          end
+
+          context "when selecting roles not included in ROLE" do
+            let(:roles) { [:app] }
+            it "ignores it" do
+              expect(subject).to eq %w{1 2}
+            end
+          end
+        end
+
+        context "with the HOSTS environment variable set" do
+          before do
+            ENV.stubs(:[]).with("ROLES").returns(nil)
+            ENV.stubs(:[]).with("HOSTS").returns("3,5")
+          end
+
+          context "when selecting all roles" do
+            let(:roles) { [:all] }
+            it "ignores it" do
+              expect(subject).to eq %w{1 2 3 4 5}
+            end
+          end
+
+          context "when selecting specific roles" do
+            let(:roles) { %i(app web) }
+            it "ignores it" do
+              expect(subject).to eq %w{1 2 3 4}
+            end
+          end
+
+          context "when selecting no roles" do
+            let(:roles) { [] }
+            it "ignores it" do
+              expect(subject).to be_empty
+            end
+          end
+        end
+      end
+    end
+  end
+end