ronin-db-activerecord 0.1.0.beta1 → 0.1.0.beta2

data/spec/arch_spec.rb

@@ -1,228 +0,0 @@
-require 'spec_helper'
-require 'ronin/db/arch'
-
-describe Ronin::DB::Arch do
-  it "must use the 'ronin_arches' table" do
-    expect(described_class.table_name).to eq('ronin_arches')
-  end
-
-  let(:name)      { 'cats'  }
-  let(:endian)    { :little }
-  let(:word_size) { 4       }
-
-  it "must include Ronin::DB::Model" do
-    expect(described_class).to include(Ronin::DB::Model)
-  end
-
-  it "must include Ronin::DB::Model::HasUniqueName" do
-    expect(described_class).to include(Ronin::DB::Model::HasUniqueName)
-  end
-
-  describe "validations" do
-    describe "name" do
-      it "must requier a name" do
-        arch = described_class.new(endian: endian, word_size: word_size)
-        expect(arch).to_not be_valid
-        expect(arch.errors[:name]).to eq(
-          ["can't be blank"]
-        )
-
-        arch = described_class.new(
-          name:      name,
-          endian:    endian,
-          word_size: word_size
-        )
-        expect(arch).to be_valid
-      end
-    end
-
-    describe "endian" do
-      subject do
-        described_class.new(
-          name:      name,
-          word_size: word_size
-        )
-      end
-
-      it "must accept :little" do
-        arch = described_class.new(
-          name:      name,
-          endian:    :little,
-          word_size: word_size
-        )
-        expect(arch).to be_valid
-      end
-
-      it "must accept :big" do
-        arch = described_class.new(
-          name:      name,
-          endian:    :big,
-          word_size: word_size
-        )
-        expect(arch).to be_valid
-      end
-
-      context "otherwise" do
-        let(:endian) { :foo }
-
-        it do
-          expect {
-            described_class.new(
-              name:      name,
-              endian:    endian,
-              word_size: word_size
-            )
-          }.to raise_error(ArgumentError,"'#{endian}' is not a valid endian")
-        end
-      end
-    end
-
-    describe "word_size" do
-      it "must require a word_size" do
-        arch = described_class.new(name: name, endian: endian)
-        expect(arch).to_not be_valid
-        expect(arch.errors[:word_size]).to include("can't be blank")
-
-        arch = described_class.new(
-          name:      name,
-          endian:    endian,
-          word_size: word_size
-        )
-        expect(arch).to be_valid
-      end
-
-      it "must accept a word_size of 4" do
-        arch = described_class.new(
-          name:      name,
-          endian:    endian,
-          word_size: 4 
-        )
-        expect(arch).to be_valid
-      end
-
-      it "must accept a word_size of 8" do
-        arch = described_class.new(
-          name:      name,
-          endian:    endian,
-          word_size: 8 
-        )
-        expect(arch).to be_valid
-      end
-
-      context "otherwise" do
-        let(:word_size) { 3 }
-
-        it do
-          arch = described_class.new(
-            name:      name,
-            endian:    endian,
-            word_size: word_size
-          )
-          expect(arch).to_not be_valid
-          expect(arch.errors[:word_size]).to eq(
-            ['is not included in the list']
-          )
-        end
-      end
-    end
-  end
-
-  describe ".x86" do
-    subject { described_class.x86 }
-
-    it "should return the x86 architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('x86')
-    end
-  end
-
-  describe ".i686" do
-    subject { described_class.i686 }
-
-    it "should return the i686 architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('i686')
-    end
-  end
-
-  describe ".x86_64" do
-    subject { described_class.x86_64 }
-
-    it "should return the x86-64 architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('x86-64')
-    end
-  end
-
-  describe ".ppc" do
-    subject { described_class.ppc }
-
-    it "should return the PPC architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('PPC')
-    end
-  end
-
-  describe ".ppc64" do
-    subject { described_class.ppc64 }
-
-    it "should return the PPC64 architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('PPC64')
-    end
-  end
-
-  describe ".mips" do
-    subject { described_class.mips }
-
-    it "should return the MIPS architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('MIPS')
-    end
-  end
-
-  describe ".mips_le" do
-    subject { described_class.mips_le }
-
-    it "should return the MIPS (Little-Endian) architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('MIPS (Little-Endian)')
-    end
-  end
-
-  describe ".mips_be" do
-    subject { described_class.mips_be }
-
-    it "should return the MIPS (Big-Endian) architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('MIPS (Big-Endian)')
-    end
-  end
-
-  describe ".arm" do
-    subject { described_class.arm }
-
-    it "should return the ARM architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('ARM')
-    end
-  end
-
-  describe ".arm_le" do
-    subject { described_class.arm_le }
-
-    it "should return the ARM (Little-Endian) architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('ARM (Little-Endian)')
-    end
-  end
-
-  describe ".arm_be" do
-    subject { described_class.arm_be }
-
-    it "should return the ARM (Big-Endian) architecture" do
-      expect(subject).to be_kind_of(described_class)
-      expect(subject.name).to eq('ARM (Big-Endian)')
-    end
-  end
-end

data/spec/asn_spec.rb

@@ -1,504 +0,0 @@
-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