ruby-nmap 0.9.3 → 1.0.0

data/spec/command_spec.rb

@@ -0,0 +1,726 @@
+require 'spec_helper'
+require 'nmap/command'
+
+describe Nmap::Command do
+  describe described_class::Port do
+    describe "#validate" do
+      context "when given an Integer" do
+        let(:value) { 443 }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+
+        context "but it's less than 1" do
+          let(:value) { 0 }
+
+          it "must return [false, \"(...) not within the range of acceptable values (1..65535)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "(#{value.inspect}) not within the range of acceptable values (1..65535)"]
+            )
+          end
+        end
+
+        context "but it's greater than 65535" do
+          let(:value) { 65536 }
+
+          it "must return [false, \"(...) not within the range of acceptable values (1..65535)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "(#{value.inspect}) not within the range of acceptable values (1..65535)"]
+            )
+          end
+        end
+      end
+
+      context "when given a String" do
+        context "and it's a number" do
+          let(:value) { '443' }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+
+          context "but it's less than 1" do
+            let(:value) { '0' }
+
+            it "must return [false, \"(...) not within the range of acceptable values (1..65535)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "(#{value.inspect}) not within the range of acceptable values (1..65535)"]
+              )
+            end
+          end
+
+          context "but it's greater than 65535" do
+            let(:value) { '65536' }
+
+            it "must return [false, \"(...) not within the range of acceptable values (1..65535)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "(#{value.inspect}) not within the range of acceptable values (1..65535)"]
+              )
+            end
+          end
+        end
+
+        context "and it's a service name" do
+          let(:value) { "http" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+
+          context "and it ends with a '*' character" do
+            let(:value) { "http*" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "and it contains uppercase letters" do
+            let(:value) { "XmlIpcRegSvc" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "and it starts with digits" do
+            let(:value) { "1ci-smcs" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "and it contains digits" do
+            let(:value) { "neo4j" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "and it contains a '-' character" do
+            let(:value) { "3gpp-cbsp" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "but it starts with a '-' character" do
+            let(:value) { "-foo" }
+
+            it "must return [false, \"must be a port number or service name (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a port number or service name (#{value.inspect})"]
+              )
+            end
+          end
+
+          context "but it ends with a '-' character" do
+            let(:value) { "foo-" }
+
+            it "must return [false, \"must be a port number or service name (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a port number or service name (#{value.inspect})"]
+              )
+            end
+          end
+
+          context "and it contains a '_' character" do
+            let(:value) { "kerberos_master" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "but it starts with a '_' character" do
+            let(:value) { "_foo" }
+
+            it "must return [false, \"must be a port number or service name (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a port number or service name (#{value.inspect})"]
+              )
+            end
+          end
+
+          context "but it ends with a '_' character" do
+            let(:value) { "foo_" }
+
+            it "must return [false, \"must be a port number or service name (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a port number or service name (#{value.inspect})"]
+              )
+            end
+          end
+
+          context "and it contain's a '/' character" do
+            let(:value) { "cl/1" }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "but it starts with a '/' character" do
+            let(:value) { "/foo" }
+
+            it "must return [false, \"must be a port number or service name (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a port number or service name (#{value.inspect})"]
+              )
+            end
+          end
+
+          context "but it starts with a '/' character" do
+            let(:value) { "foo/" }
+
+            it "must return [false, \"must be a port number or service name (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "must be a port number or service name (#{value.inspect})"]
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe described_class::PortRange do
+    describe "#validate" do
+      context "when given an Integer value" do
+      end
+
+      context "when given a String value" do
+      end
+
+      context "when given a Range of port numbers" do
+        let(:value) { (1..1024) }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+      end
+    end
+
+    describe "#format" do
+      context "when given a single port number" do
+        let(:value) { 443 }
+
+        it "must return the formatted port number" do
+          expect(subject.format(value)).to eq(value.to_s)
+        end
+      end
+
+      context "when given a Range of port numbers" do
+        let(:value) { 1..1024 }
+
+        it "must return the formatted port number range (ex: 1-102)" do
+          expect(subject.format(value)).to eq("#{value.begin}-#{value.end}")
+        end
+      end
+    end
+  end
+
+  describe described_class::PortRangeList do
+    describe "#validate" do
+      context "when given a single port number" do
+        let(:value) { 443 }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+      end
+
+      context "when given a Range of port numbers" do
+        let(:value) { (1..1024) }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+      end
+
+      context "when given an Array of port numbers" do
+        let(:value) { [80, 443] }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+
+        context "but the Array is empty" do
+          let(:value) { [] }
+
+          it "must return [false, \"cannot be empty\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "cannot be empty"]
+            )
+          end
+        end
+
+        context "and the Array contains Ranges" do
+          let(:value) { [80, (1..42), 443] }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+      end
+
+      context "when given a Hash of protocols and port numbers" do
+        let(:value) do
+          {tcp: [1,2,3,4], udp: [1,2,3,4], sctp: [1,2,3,4]}
+        end
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+
+        context "but the Hash is empty" do
+          let(:value) { {} }
+
+          it "must return [false, \"cannot be empty\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "cannot be empty"]
+            )
+          end
+        end
+
+        context "but one of the keys is not a known protocol" do
+          let(:protocol) { :foo }
+          let(:value) do
+            {tcp: [1,2,3,4], protocol => [1,2,3,4]}
+          end
+
+          it "must return [false, \"unknown protocol (...) must be :tcp, :udp, :sctp\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "unknown protocol (#{protocol.inspect}) must be :tcp, :udp, or :sctp"]
+            )
+          end
+        end
+
+        context "but one of the Hash values is not a valid port list class" do
+          let(:bad_port_list) { Object.new }
+          let(:value) do
+            {tcp: [1,2,3,4], udp: bad_port_list, sctp: [1,2,3,4]}
+          end
+
+          it "must return [false, \"cannot be converted into an Integer\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "element cannot be converted into an Integer (#{bad_port_list.inspect})"]
+            )
+          end
+        end
+
+        context "but one of the elements within the port list is not a port" do
+          let(:bad_port) { "" }
+          let(:value) do
+            {tcp: [1,2,3,4], udp: [1, bad_port, 3], sctp: [1,2,3,4]}
+          end
+
+          it "must return [false, \"element not a valid port range (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "element not a valid port range (#{bad_port.inspect})"]
+            )
+          end
+        end
+      end
+    end
+
+    describe "#format" do
+      context "when given a single port number" do
+        let(:value) { 443 }
+
+        it "must return the formatted port number" do
+          expect(subject.format(value)).to eq(value.to_s)
+        end
+      end
+
+      context "when given a Range of port numbers" do
+        let(:value) { (1..1024) }
+
+        it "must return the formatted port number range (ex: 1-102)" do
+          expect(subject.format(value)).to eq("#{value.begin}-#{value.end}")
+        end
+      end
+
+      context "when given an Array of port numbers" do
+        let(:value) { [80, 443] }
+
+        it "must return the formatted list of port numbers" do
+          expect(subject.format(value)).to eq(value.join(','))
+        end
+
+        context "and the Array contains Ranges" do
+          let(:value) { [80, (1..42), 443] }
+
+          it "must return the formatted list of port numbers and port ranges" do
+            expect(subject.format(value)).to eq("#{value[0]},#{value[1].begin}-#{value[1].end},#{value[2]}")
+          end
+        end
+      end
+
+      context "when given a Hash of protocols and port numbers" do
+        let(:value) do
+          {tcp: [1,2,3,4], udp: [1,2,3,4], sctp: [1,2,3,4]}
+        end
+
+        it "must convert the keys to capital protocol letters and format the values" do
+          expect(subject.format(value)).to eq(
+            "T:#{subject.format(value[:tcp])},U:#{subject.format(value[:udp])},S:#{subject.format(value[:sctp])}"
+          )
+        end
+      end
+    end
+  end
+
+  describe described_class::Time do
+    describe "#validate" do
+      context "when given nil" do
+        let(:value) { nil }
+
+        it "must return [false, \"cannot be nil\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be nil"]
+          )
+        end
+      end
+
+      context "when given an Integer" do
+        let(:value) { 10 }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+      end
+
+      context "when given a String" do
+        context "when given an empty String" do
+          let(:value) { "" }
+
+          it "must return [false, \"does not allow an empty value\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "does not allow an empty value"]
+            )
+          end
+        end
+
+        context "when given a number" do
+          let(:value) { "10" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "when given a number that ends with 'ms'" do
+          let(:value) { "10ms" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "when given a number that ends with 's'" do
+          let(:value) { "10s" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "when given a number that ends with 'm'" do
+          let(:value) { "10m" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "when given a number that ends with 'h'" do
+          let(:value) { "10h" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "when given a number that ends with an unrecognized unit" do
+          let(:value) { "10x" }
+
+          it "must return [false, \"must be a number and end with 'ms', 's', 'm', or 'h'\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "must be a number and end with 'ms', 's', 'm', or 'h'"]
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe described_class::HexString do
+    describe "#validate" do
+      context "when given nil" do
+        let(:value) { nil }
+
+        it "must return [false, \"cannot be nil\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be nil"]
+          )
+        end
+      end
+
+      context "when given a String" do
+        context "but it's empty" do
+          let(:value) { '' }
+
+          it "must return [false, \"does not allow an empty value\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "does not allow an empty value"]
+            )
+          end
+        end
+
+        context "and it's of the format 0xAABBCCDDEEFF" do
+          let(:value) { "0xAABBCCDDEEFF" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "and it's of the format AABBCCDDEEFF" do
+          let(:value) { "AABBCCDDEEFF" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "and it's of the format \\xAA\\xBB\\xCC\\xDD\\xEE\\xFF" do
+          let(:value) { "\\xAA\\xBB\\xCC\\xDD\\xEE\\xFF" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "but it contains non-hex characters" do
+          let(:value) { "abcxyz123" }
+
+          it "must return [false, \"must be of the format 0xAABBCCDDEEFF..., AABBCCDDEEFF..., or \\\\xAA\\\\xBB\\\\xCC\\\\xDD\\\\xEE\\\\xFF...\"]" do
+            expect(subject.validate(value)).to eq(
+              [false,  "must be of the format 0xAABBCCDDEEFF..., AABBCCDDEEFF..., or \\xAA\\xBB\\xCC\\xDD\\xEE\\xFF..."]
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe described_class::ScanFlags do
+    describe "#validate" do
+      context "when given nil" do
+        let(:value) { nil }
+
+        it "must return [false, \"cannot be nil\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be nil"]
+          )
+        end
+      end
+
+      context "when given a String" do
+        context "but it's empty" do
+          let(:value) { '' }
+
+          it "must return [false, \"does not allow an empty value\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "does not allow an empty value"]
+            )
+          end
+        end
+
+        context "and it's made up of 'URG', 'ACK', 'PSH', 'RST', 'SYN', and 'FIN'" do
+          let(:value) { 'URGACKPSHRSTSYNFIN' }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "but it contains other sub-strings besides 'URG', 'ACK', 'PSH', 'RST', 'SYN', and 'FIN'" do
+          let(:value) { 'URGACKPSHRSTSYNFINXXX' }
+
+          it "must return [false, \"must only contain URG, ACK, PSH, RST, SYN, or FIN\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "must only contain URG, ACK, PSH, RST, SYN, or FIN"]
+            )
+          end
+        end
+
+        context "and it's numeric" do
+          let(:value) { '9' }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+      end
+
+      context "when given an Integer" do
+        let(:value) { 9 }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+      end
+
+      context "when given an Array" do
+        context "but it's empty" do
+          let(:value) { [] }
+
+          it "must return [false, \"Array value cannot be empty\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "Array value cannot be empty"]
+            )
+          end
+        end
+
+        context "and it contains :urg, :ack, :psh, :rst, :syn, or :fin" do
+          let(:value) { [:urg, :ack, :psh, :rst, :syn, :fin] }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "but it contains other values besides :urg, :ack, :psh, :rst, :syn, and :fin" do
+          let(:other) { :foo }
+          let(:value) { [:urg, :ack, :psh, :rst, :syn, :fin, other] }
+
+          it "must return true" do
+            expect(subject.validate(value)).to eq(
+              [false, "Array must only contain the values :urg, :ack, :psh, :rst, :syn, or :fin"]
+            )
+          end
+        end
+      end
+
+      context "when given a Hash" do
+        context "but it's empty" do
+          let(:value) { {} }
+
+          it "must return [false, \"Hash value cannot be empty\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "Hash value cannot be empty"]
+            )
+          end
+        end
+
+        context "and it's keys contain :urg, :ack, :psh, :rst, :syn, or :fin" do
+          context "and it's values are all Boolean" do
+            let(:value) do
+              {
+                urg: true,
+                ack: true,
+                psh: false,
+                rst: nil,
+                syn: true,
+                fin: true
+              }
+            end
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "but one of it's values is not a Boolean value" do
+            let(:value) do
+              {
+                urg: true,
+                ack: true,
+                psh: false,
+                rst: nil,
+                syn: true,
+                fin: "foo"
+              }
+            end
+
+            it "must return [false, \"must only contain the Boolean values\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "Hash must only contain the values true, false, or nil"]
+              )
+            end
+          end
+        end
+
+        context "but it's keys contains other values besides :urg, :ack, :psh, :rst, :syn, and :fin" do
+          let(:other) { :foo }
+          let(:value) do
+            {
+              urg: true,
+              ack: true,
+              psh: true,
+              rst: true,
+              syn: true,
+              fin: true,
+              other => true
+            }
+          end
+
+          it "must return [false, \"must only contain the keys :urg, :ack, :psh, :rst, :syn, or :fin\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "Hash must only contain the keys :urg, :ack, :psh, :rst, :syn, or :fin"]
+            )
+          end
+        end
+      end
+    end
+
+    describe "#format" do
+      context "when given a String" do
+        let(:value) { 'PSHFIN' }
+
+        it "must return the String" do
+          expect(subject.format(value)).to eq(value)
+        end
+      end
+
+      context "when given an Integer" do
+        let(:value) { 9 }
+
+        it "must return the String version of the Integer" do
+          expect(subject.format(value)).to eq(value.to_s)
+        end
+      end
+
+      context "when given an Array" do
+        let(:value) { [:urg, :ack, :psh, :rst, :syn, :fin] }
+
+        it "must map each Symbol to their flag names value and join them together" do
+          expect(subject.format(value)).to eq("URGACKPSHRSTSYNFIN")
+        end
+      end
+
+      context "when given a Hash" do
+        let(:value) do
+          {
+            urg: true,
+            ack: true,
+            psh: false,
+            rst: nil,
+            syn: true,
+            fin: true
+          }
+        end
+
+        it "must map the keys with true values to their flag names and join them together" do
+          expect(subject.format(value)).to eq("URGACKSYNFIN")
+        end
+      end
+    end
+  end
+end