loom-core 0.0.1

data/spec/loom/host_spec_spec.rb

@@ -0,0 +1,101 @@
+require 'loom/host_spec'
+
+describe Loom::HostSpec do
+
+  subject { Loom::HostSpec.new host_string }
+
+  context "local strings" do
+
+    context "with no user/nor port" do
+      let(:host_string) { "localhost" }
+
+      it "parses localhost configurations" do
+        expect(subject.is_localhost?).to be true
+        expect(subject.is_remote?).to be false
+      end
+
+      it "has been parsed" do
+        expect(subject.hostname).to eq "localhost"
+        expect(subject.user).to be nil
+        expect(subject.port).to be nil
+      end
+    end
+
+    context "with a user" do
+      let(:host_string) { "ej@localhost" }
+
+      it "parses configurations as remote" do
+        expect(subject.is_localhost?).to be false
+        expect(subject.is_remote?).to be true
+      end
+
+      it "has been parsed" do
+        expect(subject.hostname).to eq "localhost"
+        expect(subject.user).to eq "ej"
+        expect(subject.port).to be nil
+      end
+    end
+
+    context "with a port" do
+      let(:host_string) { "localhost:22" }
+
+      it "parses configurations as remote" do
+        expect(subject.is_localhost?).to be false
+        expect(subject.is_remote?).to be true
+      end
+
+      it "has been parsed" do
+        expect(subject.hostname).to eq "localhost"
+        expect(subject.user).to be nil
+        expect(subject.port).to eq 22
+      end
+    end
+
+  end
+
+  context "remote strings" do
+
+    let(:host_string) { "erick@remote.machine:27" }
+
+    it "parses user@localhost configurations as remote" do
+      expect(subject.is_localhost?).to be false
+      expect(subject.is_remote?).to be true
+    end
+
+    it "has been parsed" do
+      expect(subject.user).to eq "erick"
+      expect(subject.hostname).to eq "remote.machine"
+      expect(subject.port).to eq 27
+    end
+  end
+
+  context "ipv4 addresses" do
+    let(:host_string) { "erick@192.168.1.100:27" }
+
+    it "parses user@localhost configurations as remote" do
+      expect(subject.is_localhost?).to be false
+      expect(subject.is_remote?).to be true
+    end
+
+    it "has been parsed" do
+      expect(subject.user).to eq "erick"
+      expect(subject.hostname).to eq "192.168.1.100"
+      expect(subject.port).to eq 27
+    end
+  end
+
+  context "ipv6 addresses" do
+    let(:host_string) { "[2a02:120b:2c28:5920:6257:18ff:febf:13c8:22]" }
+
+    it "parses user@localhost configurations as remote" do
+      expect(subject.is_localhost?).to be false
+      expect(subject.is_remote?).to be true
+    end
+
+    it "has been parsed" do
+      expect(subject.hostname).to eq "2a02:120b:2c28:5920:6257:18ff:febf:13c8"
+      expect(subject.user).to be nil
+      expect(subject.port).to eq 22
+    end
+  end
+end

data/spec/loom/inventory_spec.rb

@@ -0,0 +1,154 @@
+require "loom/config"
+require "loom/inventory"
+require "tmpdir"
+require "yaml"
+
+describe Loom::Inventory do
+
+  HOSTLIST = %w[host1 host2 host3]
+  HOSTGROUPS = {
+    :group1 => %w[g1host g2host],
+    :duplicate_group => %w[host1]
+  }
+
+  INVENTORY_HOSTLIST = [
+    'inv.host1',
+    'inv.host2',
+    :inventory_group => ['inv.group.host'],
+    'string_group' => ['string.group.host']
+  ]
+
+  class TmpInventoryFile
+    def self.transaction(search_paths_list, &block)
+      Dir.mktmpdir do |dir|
+        search_paths_list << dir
+
+        File.open File.join(dir, "inventory.yml"), "w" do
+          |f| f << INVENTORY_HOSTLIST.to_yaml
+        end
+        yield
+      end
+    end
+  end
+
+  CONFIG_DEFAULTS = {
+    :loom_search_paths => []
+  }
+
+  let(:config_map) { {} }
+  let(:config) do
+    Loom::Config.configure do |c|
+      CONFIG_DEFAULTS.merge(config_map).each { |k,v| c[k] = v }
+    end
+  end
+
+  context "methods" do
+
+    subject { Loom::Inventory::InventoryList.new hostlist, hostgroups }
+    let(:hostlist) { HOSTLIST }
+    let(:hostgroups) { {} }
+
+    it "#hosts should parse hostnames" do
+      expect(subject.hosts.first).to be_a Loom::HostSpec
+      expect(subject.hosts.size).to be 3
+    end
+
+    it "#disable marks hosts #disabled?" do
+      expect(subject.disabled? "host1").to be false
+      subject.disable "host1"
+      expect(subject.disabled? "host1").to be true
+      expect(subject.disabled? "host2").to be false
+    end
+
+    it "lists #hostnames" do
+      expect(subject.hostnames).to eql %w[host1 host2 host3]
+    end
+
+    context "with groups" do
+
+      let(:hostgroups) { HOSTGROUPS }
+
+      context "#hostnames" do
+        it "#hostnames includes hostnames from the group" do
+          expect(subject.hostnames).to include("g1host")
+        end
+
+        it "only lists unique hosts" do
+          expect(subject.hostnames.size).to be 5
+        end
+      end
+
+      it "lists #group_names" do
+        expect(subject.group_names).to eq [:group1, :duplicate_group]
+      end
+    end
+  end
+
+  context "#total_inventory" do
+
+    subject { Loom::Inventory::InventoryList.total_inventory config }
+
+    context "with explicit hosts configured" do
+
+      let(:config_map) { {:inventory_hosts => %w[confighost1 confighost2]} }
+
+      it "gets hosts from config" do
+        expect(subject.hostnames).to eq %w[confighost1 confighost2]
+      end
+    end
+
+    context "with inventory files" do
+
+      # To be passed into the TmpInventoryFile.transaction by :around
+      let(:config_map) { {:loom_search_paths => []} }
+
+      around(:example) do |example|
+        TmpInventoryFile.transaction config_map[:loom_search_paths], &example
+      end
+
+      it "finds hosts in the tmp config" do
+        expected = %w[inv.host1 inv.host2 inv.group.host string.group.host]
+        expect(subject.hostnames).to match_array expected
+      end
+
+    end
+  end
+
+  context "#active_inventory" do
+
+    subject { Loom::Inventory::InventoryList.active_inventory config }
+
+    context "with inventory file" do
+
+      around(:example) do |example|
+        TmpInventoryFile.transaction config_map[:loom_search_paths], &example
+      end
+
+      context "with explicit hosts" do
+
+        # To be passed into the TmpInventoryFile.transaction by :around
+        let(:config_map) do
+          {:inventory_hosts => HOSTLIST, :loom_search_paths => []}
+        end
+
+        it "gets only explicit hosts from config" do
+          expect(subject.hostnames).to eq HOSTLIST
+        end
+      end
+
+      context "with explicit groups" do
+
+        # To be passed into the TmpInventoryFile.transaction by :around
+        let(:config_map) do
+          {:inventory_groups => [:inventory_group, :string_group],
+           :loom_search_paths => []}
+        end
+
+        it "gets only explicit hosts from config" do
+          expect(subject.hostnames).to match_array %w[inv.group.host string.group.host]
+        end
+
+      end
+    end
+  end
+end

data/spec/loom/method_signature_spec.rb

@@ -0,0 +1,275 @@
+require "loom/method_signature"
+
+describe Loom::MethodSignature do
+
+  module MethodModule
+    def one_req_arg(req); end
+    def two_req_args(req1, req2); end
+
+    def opt_arg(opt=nil); end
+    def two_opt_args(opt1=1, opt2=nil); end
+
+    def rest_args(*rest); end
+    def req_and_rest_args(req, *rest); end
+    def req_and_opt_and_rest_args(req, opt=nil, *rest); end
+
+    def one_keyreq_arg(keyreq:); end
+    def two_keyreq_args(keyreq1:, keyreq2:); end
+
+    def one_key_arg(key: 1); end
+    def two_key_args(key1: 1, key2: nil); end
+
+    def keyrest_arg(**keyrest); end
+    def key_and_keyrest_arg(keyreq:, key: 2, **keyrest); end
+
+    def block_arg(&block); end
+
+    def all_args(req, opt=1, *rest, keyreq:, key: 2, **keyrest, &block); end
+    def no_args; end
+
+    class << self
+      def [](method_name)
+        MethodModule.instance_method method_name
+      end
+    end
+  end
+
+  context Loom::MethodSignature do
+
+    context "#one_req_arg" do
+      subject { Loom::MethodSignature.new MethodModule[:one_req_arg] }
+
+      it "has the right signature" do
+        expect(subject.req_args.size).to be 1
+      end
+
+      it "implements has_xyz_args?" do
+        expect(subject.has_req_args?).to be true
+        expect(subject.has_opt_args?).to be false
+        expect(subject.has_rest_args?).to be false
+      end
+    end
+
+    context "#one_req_arg" do
+      subject { Loom::MethodSignature.new MethodModule[:one_keyreq_arg] }
+
+      it "has the right signature" do
+        expect(subject.keyreq_args.size).to be 1
+      end
+
+      it "implements has_xyz_args?" do
+        expect(subject.has_keyreq_args?).to be true
+        expect(subject.has_key_args?).to be false
+        expect(subject.has_keyrest_args?).to be false
+      end
+    end
+
+    context "#keyrest_arg" do
+      subject { Loom::MethodSignature.new MethodModule[:keyrest_arg] }
+
+      it "has the right signature" do
+        expect(subject.keyrest_args.size).to be 1
+      end
+
+      it "implements has_xyz_args?" do
+        expect(subject.has_keyreq_args?).to be false
+        expect(subject.has_key_args?).to be false
+        expect(subject.has_keyrest_args?).to be true
+      end
+    end
+
+    context "#two_key_args" do
+      subject { Loom::MethodSignature.new MethodModule[:two_key_args] }
+
+      it "has the right signature" do
+        expect(subject.req_args.size).to be 0
+        expect(subject.opt_args.size).to be 0
+        expect(subject.rest_args.size).to be 0
+
+        expect(subject.keyreq_args.size).to be 0
+        expect(subject.key_args.size).to be 2
+        expect(subject.keyrest_args.size).to be 0
+
+        expect(subject.block_args.size).to be 0
+      end
+    end
+
+    context "#all_args" do
+      subject { Loom::MethodSignature.new MethodModule[:all_args] }
+
+      it "has the right signature" do
+        expect(subject.req_args.size).to be 1
+        expect(subject.opt_args.size).to be 1
+        expect(subject.rest_args.size).to be 1
+
+        expect(subject.keyreq_args.size).to be 1
+        expect(subject.key_args.size).to be 1
+        expect(subject.keyrest_args.size).to be 1
+
+        expect(subject.block_args.size).to be 1
+      end
+
+      it "implements has_xyz_args?" do
+        expect(subject.has_req_args?).to be true
+        expect(subject.has_opt_args?).to be true
+        expect(subject.has_rest_args?).to be true
+
+        expect(subject.has_keyreq_args?).to be true
+        expect(subject.has_key_args?).to be true
+        expect(subject.has_keyrest_args?).to be true
+
+        expect(subject.has_block_args?).to be true
+      end
+    end
+
+    context "#no_args" do
+      subject { Loom::MethodSignature.new MethodModule[:no_args] }
+
+      it "has the right signature" do
+        expect(subject.req_args.size).to be 0
+        expect(subject.opt_args.size).to be 0
+        expect(subject.rest_args.size).to be 0
+
+        expect(subject.keyreq_args.size).to be 0
+        expect(subject.key_args.size).to be 0
+        expect(subject.keyrest_args.size).to be 0
+        expect(subject.block_args.size).to be 0
+      end
+
+      it "implements has_xyz_args?" do
+        expect(subject.has_req_args?).to be false
+        expect(subject.has_opt_args?).to be false
+        expect(subject.has_rest_args?).to be false
+
+        expect(subject.has_keyreq_args?).to be false
+        expect(subject.has_key_args?).to be false
+        expect(subject.has_keyrest_args?).to be false
+
+        expect(subject.has_block_args?).to be false
+      end
+    end
+  end
+
+  context Loom::MethodSignature::MatchSpec do
+
+    context 'with required argument matching' do
+
+      subject { Loom::MethodSignature::MatchSpec.builder.req_args(1).build }
+      let(:passing_methods) { [:one_req_arg, :rest] }
+
+      MethodModule.instance_methods.each do |m|
+        it "checks ##{m} for matches" do
+          v = passing_methods.include? m
+          expect(subject.match?(MethodModule[m])).to be v
+        end
+      end
+    end
+
+    context 'with optional argument matching' do
+
+      subject { Loom::MethodSignature::MatchSpec.builder.opt_args(1).build }
+      let(:passing_methods) { [:opt_arg, :rest] }
+
+      MethodModule.instance_methods.each do |m|
+        it "checks ##{m} for matches" do
+          v = passing_methods.include? m
+          expect(subject.match?(MethodModule[m])).to be v
+        end
+      end
+    end
+
+    context 'with required keyword argument matching' do
+
+      subject { Loom::MethodSignature::MatchSpec.builder.keyreq_args(1).build }
+      let(:passing_methods) { [:one_keyreq_arg] }
+
+      MethodModule.instance_methods.each do |m|
+        it "checks ##{m} for matches" do
+          v = passing_methods.include? m
+          expect(subject.match?(MethodModule[m])).to be v
+        end
+      end
+    end
+
+    context 'with optional keyword argument matching' do
+
+      subject { Loom::MethodSignature::MatchSpec.builder.key_args(1).build }
+      let(:passing_methods) { [:one_key_arg] }
+
+      MethodModule.instance_methods.each do |m|
+        it "checks ##{m} for matches" do
+          v = passing_methods.include? m
+          expect(subject.match?(MethodModule[m])).to be v
+        end
+      end
+    end
+
+    context 'with a pattern signature' do
+
+      subject do
+        Loom::MethodSignature::MatchSpec.builder
+          .req_args(2)
+          .has_rest_args(nil)
+          .has_keyrest_args(nil)
+          .has_block(nil)
+          .build
+      end
+
+      let(:valid) { lambda do |loom, config| end }
+      let(:valid2) { lambda do |loom, config, *args| end }
+      let(:valid3) { lambda do |*args| end }
+      let(:invalid) { lambda do |loom, config, other| end }
+
+      it "checks :valid passes for well formatted pattern" do
+        expect(subject.match?(valid)).to be true
+      end
+
+      it "checks :valid2 passes for well formatted pattern" do
+        expect(subject.match?(valid2)).to be true
+      end
+
+      it "checks :valid2 passes for well formatted pattern" do
+        expect(subject.match?(valid3)).to be true
+      end
+
+      it "checks :invalid fails for badly formatted pattern" do
+        expect(subject.match?(invalid)).to be false
+      end
+
+    end
+
+    context 'with a mod signature' do
+
+      subject do
+        Loom::MethodSignature::MatchSpec.builder
+          .req_args(2)
+          .has_rest_args(nil)
+          .has_keyrest_args(true)
+          .has_block(nil)
+          .build
+      end
+
+      let(:valid) { lambda do |loom, config, *args, **rest| end }
+      let(:valid2) { lambda do |loom, config, **rest| end }
+      let(:valid3) { lambda do |loom, config, foo:, bar: nil| end }
+      let(:invalid) { lambda do |loom, config, foo, bar| end }
+
+      it "checks :valid passes for well formatted pattern" do
+        expect(subject.match?(valid)).to be true
+      end
+
+      it "checks :valid2 passes for well formatted pattern" do
+        expect(subject.match?(valid2)).to be true
+      end
+
+      it "checks :valid3 passes for well formatted pattern" do
+        expect(subject.match?(valid3)).to be true
+      end
+
+      it "checks :invalid fails for badly formatted pattern" do
+        expect(subject.match?(invalid)).to be false
+      end
+
+    end
+  end
+end