ronin-db-activerecord 0.1.0.beta1

data/spec/asn_spec.rb

@@ -0,0 +1,504 @@
+require 'spec_helper'
+require 'ronin/db/asn'
+
+describe Ronin::DB::ASN do
+  it "must use the 'ronin_asns' table" do
+    expect(described_class.table_name).to eq('ronin_asns')
+  end
+
+  let(:version)      { 4 }
+  let(:range_start)  { '4.0.0.0' }
+  let(:range_end)    { '4.7.168.255' }
+  let(:number)       { 3356 }
+  let(:country_code) { 'US' }
+  let(:name)         { 'LEVEL3' }
+
+  describe "validations" do
+    describe "version" do
+      it "must require a version" do
+        asn = described_class.new(
+          range_start:  range_start,
+          range_end:    range_end,
+          number:       number,
+          country_code: country_code,
+          name:         name
+        )
+
+        expect(asn).to_not be_valid
+        expect(asn.errors[:version]).to eq(
+          ["can't be blank", "is not included in the list"]
+        )
+      end
+
+      it "must accept a value of 4" do
+        asn = described_class.new(
+          version:      4,
+          range_start:  range_start,
+          range_end:    range_end,
+          number:       number,
+          country_code: country_code,
+          name:         name
+        )
+
+        expect(asn).to be_valid
+      end
+
+      it "must accept a value of 6" do
+        asn = described_class.new(
+          version:      6,
+          range_start:  range_start,
+          range_end:    range_end,
+          number:       number,
+          country_code: country_code,
+          name:         name
+        )
+
+        expect(asn).to be_valid
+      end
+    end
+
+    describe "range_start" do
+      it "must require #range_start" do
+        asn = described_class.new(
+          version:      version,
+          range_end:    range_end,
+          number:       number,
+          country_code: country_code,
+          name:         name
+        )
+
+        expect(asn).to_not be_valid
+        expect(asn.errors[:range_start]).to eq(
+          ["can't be blank"]
+        )
+      end
+    end
+
+    describe "range_end" do
+      it "must require #range_end" do
+        asn = described_class.new(
+          version:      version,
+          range_start:  range_start,
+          number:       number,
+          country_code: country_code,
+          name:         name
+        )
+
+        expect(asn).to_not be_valid
+        expect(asn.errors[:range_end]).to eq(
+          ["can't be blank"]
+        )
+      end
+    end
+
+    describe "number" do
+      it "must require #number" do
+        asn = described_class.new(
+          version:      version,
+          range_start:  range_start,
+          range_end:    range_end,
+          country_code: country_code,
+          name:         name
+        )
+
+        expect(asn).to_not be_valid
+        expect(asn.errors[:number]).to eq(
+          ["can't be blank"]
+        )
+      end
+    end
+
+    describe "country_code" do
+      it "must omit the name if unrouted" do
+        asn = described_class.new(
+          version:      version,
+          range_start:  range_start,
+          range_end:    range_end,
+          number:       number
+        )
+
+        expect(asn).to be_valid
+      end
+    end
+
+    describe "name" do
+      it "must omit the name if unrouted" do
+        asn = described_class.new(
+          version:      version,
+          range_start:  range_start,
+          range_end:    range_end,
+          number:       number
+        )
+
+        expect(asn).to be_valid
+      end
+    end
+  end
+
+  describe ".v4" do
+    subject { described_class }
+
+    before do
+      subject.create(
+        version:      6,
+        range_start:  '64:ff9b::1:0:0',
+        range_end:    '100::ffff:ffff:ffff:ffff',
+        number:       0
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  range_start,
+        range_end:    range_end,
+        number:       number,
+        country_code: country_code,
+        name:         name
+      )
+
+      subject.create(
+        version:      6,
+        range_start:  '::',
+        range_end:    '::1',
+        number:       0
+      )
+    end
+
+    it "must query all IPv4 ASNs" do
+      asns = subject.v4
+
+      expect(asns).to_not be_empty
+      expect(asns.map(&:version)).to all(eq(4))
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".v6" do
+    subject { described_class }
+
+    before do
+      subject.create(
+        version:      4,
+        range_start:  '1.0.0.0',
+        range_end:    '1.0.0.255',
+        number:       13335,
+        country_code: 'US',
+        name:         'CLOUDFLARENET'
+      )
+
+      subject.create(
+        version:      6,
+        range_start:  '64:ff9b::1:0:0',
+        range_end:    '100::ffff:ffff:ffff:ffff',
+        number:       0
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '1.0.1.0',
+        range_end:    '1.0.3.255',
+        number:       0
+      )
+    end
+
+    it "must query all IPv6 ASNs" do
+      asns = subject.v6
+
+      expect(asns).to_not be_empty
+      expect(asns.map(&:version)).to all(eq(6))
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".with_number" do
+    subject { described_class }
+
+    let(:number) { 3356 }
+
+    before do
+      subject.create(
+        version:      4,
+        range_start:  '3.248.0.0',
+        range_end:    '3.255.255.255',
+        number:       16509,
+        country_code: 'US',
+        name:         'AMAZON-02'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.0.0.0',
+        range_end:    '4.7.168.255',
+        number:       number,
+        country_code: 'US',
+        name:         'LEVEL3'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.7.169.0',
+        range_end:    '4.23.87.255',
+        number:       number,
+        country_code: 'US',
+        name:         'LEVEL3'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.23.88.0',
+        range_end:    '4.23.89.255',
+        number:       46164,
+        country_code: 'US',
+        name:         'ATT-MOBILITY-LABS'
+      )
+    end
+
+    it "must query the ASN recrds with the matching number" do
+      asns = subject.with_number(number)
+
+      expect(asns.length).to eq(2)
+      expect(asns).to all(be_kind_of(described_class))
+      expect(asns[0].number).to eq(number)
+      expect(asns[1].number).to eq(number)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".with_country_code" do
+    subject { described_class }
+
+    let(:country_code) { 'US' }
+
+    before do
+      subject.create(
+        version:      4,
+        range_start:  '3.30.0.0',
+        range_end:    '3.32.255.255',
+        number:       8987,
+        country_code: 'IE',
+        name:         'AMAZON EXPANSION'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.0.0.0',
+        range_end:    '4.7.168.255',
+        number:       3356,
+        country_code: country_code,
+        name:         'LEVEL3'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.7.169.0',
+        range_end:    '4.23.87.255',
+        number:       3356,
+        country_code: country_code,
+        name:         'LEVEL3'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '5.0.0.0',
+        range_end:    '5.0.255.255',
+        number:       29256,
+        country_code: 'SV',
+        name:         'INT-PDN-STE-AS STE PDN Internal AS'
+      )
+    end
+
+    it "must query the ASN recrds with the matching country code" do
+      asns = subject.with_country_code(country_code)
+
+      expect(asns.length).to eq(2)
+      expect(asns).to all(be_kind_of(described_class))
+      expect(asns[0].country_code).to eq(country_code)
+      expect(asns[1].country_code).to eq(country_code)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".with_name" do
+    subject { described_class }
+
+    let(:number) { 3356     }
+    let(:name)   { 'LEVEL3' }
+
+    before do
+      subject.create(
+        version:      4,
+        range_start:  '3.248.0.0',
+        range_end:    '3.255.255.255',
+        number:       16509,
+        country_code: 'US',
+        name:         'AMAZON-02'
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.0.0.0',
+        range_end:    '4.7.168.255',
+        number:       number,
+        country_code: 'US',
+        name:         name 
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.7.169.0',
+        range_end:    '4.23.87.255',
+        number:       number,
+        country_code: 'US',
+        name:         name
+      )
+
+      subject.create(
+        version:      4,
+        range_start:  '4.23.88.0',
+        range_end:    '4.23.89.255',
+        number:       46164,
+        country_code: 'US',
+        name:         'ATT-MOBILITY-LABS'
+      )
+    end
+
+    it "must query the ASN recrds with the matching number" do
+      asns = subject.with_name(name)
+
+      expect(asns.length).to eq(2)
+      expect(asns).to all(be_kind_of(described_class))
+      expect(asns[0].name).to eq(name)
+      expect(asns[1].name).to eq(name)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".containing_ip" do
+    subject { described_class }
+
+    before do
+      subject.create(
+        version:      version,
+        range_start:  range_start,
+        range_end:    range_end,
+        number:       number,
+        country_code: country_code,
+        name:         name
+      )
+    end
+
+    let(:ip) { "4.4.4.4" }
+
+    it "must find the #{described_class} that contains the given IP address" do
+      asn = subject.containing_ip(ip)
+
+      expect(asn).to be_kind_of(described_class)
+      expect(asn.version).to eq(version)
+      expect(asn.range_start).to eq(range_start)
+      expect(asn.range_end).to eq(range_end)
+      expect(asn.number).to eq(number)
+      expect(asn.country_code).to eq(country_code)
+      expect(asn.name).to eq(name)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  subject do
+    described_class.new(
+      version:      version,
+      range_start:  range_start,
+      range_end:    range_end,
+      number:       number,
+      country_code: country_code,
+      name:         name
+    )
+  end
+
+  describe "#range_start_ipaddr" do
+    context "when #range_start is set" do
+      it "must return an IPAddr of #range_start" do
+        expect(subject.range_start_ipaddr).to be_kind_of(IPAddr)
+        expect(subject.range_start_ipaddr.to_s).to eq(subject.range_start)
+      end
+    end
+
+    context "when #range_start is nil" do
+      subject { described_class.new }
+
+      it "must return nil" do
+        expect(subject.range_start_ipaddr).to be(nil)
+      end
+    end
+  end
+
+  describe "#range_end_ipaddr" do
+    context "when #range_end is set" do
+      it "must return an IPAddr of #range_end" do
+        expect(subject.range_end_ipaddr).to be_kind_of(IPAddr)
+        expect(subject.range_end_ipaddr.to_s).to eq(subject.range_end)
+      end
+    end
+
+    context "when #range_end is nil" do
+      subject { described_class.new }
+
+      it "must return nil" do
+        expect(subject.range_end_ipaddr).to be(nil)
+      end
+    end
+  end
+
+  describe "#ip_addresses" do
+    let(:address1) { '4.1.1.1' }
+    let(:address2) { '4.2.2.2' }
+    let(:address3) { '4.3.3.3' }
+
+    before do
+      Ronin::DB::IPAddress.create(address: '3.255.255.255')
+      Ronin::DB::IPAddress.create(address: address1)
+      Ronin::DB::IPAddress.create(address: address2)
+      Ronin::DB::IPAddress.create(address: address3)
+      Ronin::DB::IPAddress.create(address: '4.7.169.0')
+    end
+
+    it "must query all IP addresses that are in between the first and last IP address" do
+      ip_addresses = subject.ip_addresses
+
+      expect(ip_addresses.length).to eq(3)
+      expect(ip_addresses).to all(be_kind_of(Ronin::DB::IPAddress))
+      expect(ip_addresses[0].address).to eq(address1)
+      expect(ip_addresses[1].address).to eq(address2)
+      expect(ip_addresses[2].address).to eq(address3)
+    end
+
+    after { Ronin::DB::IPAddress.destroy_all }
+  end
+
+  describe "#save" do
+    subject do
+      described_class.create(
+        version:      4,
+        range_start:  range_start,
+        range_end:    range_end,
+        number:       number,
+        country_code: country_code,
+        name:         name
+      )
+    end
+
+    it "must set #range_start_hton" do
+      expect(subject.range_start_hton).to eq(subject.range_start_ipaddr.hton)
+    end
+
+    it "must set #range_end_hton" do
+      expect(subject.range_end_hton).to eq(subject.range_end_ipaddr.hton)
+    end
+
+    after { subject.destroy }
+  end
+end