ronin-db-activerecord 0.1.0.beta1

data/spec/ip_address_spec.rb

@@ -0,0 +1,386 @@
+require 'spec_helper'
+
+require 'ronin/db/ip_address'
+
+describe Ronin::DB::IPAddress do
+  it "must use the 'ronin_ip_addresses' table" do
+    expect(described_class.table_name).to eq('ronin_ip_addresses')
+  end
+
+  let(:address) { '127.0.0.1' }
+
+  let(:ipv4_address) { '93.184.216.34' }
+  let(:ipv6_address) { '2606:2800:220:1:248:1893:25c8:1946' }
+
+  subject { described_class.new(address: address) }
+
+  describe "validations" do
+    describe "address" do
+      it "must require an address" do
+        ip_address = described_class.new
+        expect(ip_address).to_not be_valid
+
+        ip_address = described_class.new(address: address)
+        expect(ip_address).to be_valid
+      end
+
+      it "must accept IPv4 addresses" do
+        ip_address = described_class.new(address: ipv4_address)
+        expect(ip_address).to be_valid
+      end
+      
+      it "must accept IPv6 addresses" do
+        ip_address = described_class.new(address: ipv6_address)
+        expect(ip_address).to be_valid
+      end
+
+      it "must not accept non-IP addresses" do
+        ip_address = described_class.new(address: '0')
+        expect(ip_address).to_not be_valid
+        expect(ip_address.errors[:address]).to eq(
+          ["Must be a valid IP address"]
+        )
+      end
+    end
+  end
+
+  describe ".v4" do
+    subject { described_class }
+
+    before do
+      subject.create(address: ipv4_address)
+      subject.create(address: ipv6_address)
+    end
+
+    it "must query all #{described_class} with IPv4 addresses" do
+      ip_addresses = subject.v4
+      expect(ip_addresses.count).to eq(1)
+
+      ip_address = ip_addresses.first
+      expect(ip_address).to be_kind_of(described_class)
+      expect(ip_address.address).to eq(ipv4_address)
+    end
+
+    after do
+      subject.destroy_all
+    end
+  end
+
+  describe ".v6" do
+    subject { described_class }
+
+    before do
+      subject.create(address: ipv4_address)
+      subject.create(address: ipv6_address)
+    end
+
+    it "must query all #{described_class} with IPv6 addresses" do
+      ip_addresses = subject.v6
+      expect(ip_addresses.count).to eq(1)
+
+      ip_address = ip_addresses.first
+      expect(ip_address).to be_kind_of(described_class)
+      expect(ip_address.address).to eq(ipv6_address)
+    end
+
+    after do
+      subject.destroy_all
+    end
+  end
+
+  describe ".between" do
+    subject { described_class }
+
+    let(:address1) { '4.1.1.1' }
+    let(:address2) { '4.2.2.2' }
+    let(:address3) { '4.3.3.3' }
+
+    before do
+      described_class.create(address: '4.0.0.0')
+      described_class.create(address: address1)
+      described_class.create(address: address2)
+      described_class.create(address: address3)
+      described_class.create(address: '4.4.4.4')
+    end
+
+    it "must query all IP addresses that are in between the first and last IP address" do
+      ip_addresses = subject.between(address1,address3)
+
+      expect(ip_addresses.length).to eq(3)
+      expect(ip_addresses).to all(be_kind_of(described_class))
+      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 { described_class.destroy_all }
+  end
+
+  describe ".in_range" do
+    subject { described_class }
+
+    let(:address1) { '4.1.1.1' }
+    let(:address2) { '4.2.2.2' }
+    let(:address3) { '4.3.3.3' }
+    let(:range)    { address1..address3 }
+
+    before do
+      described_class.create(address: '4.0.0.0')
+      described_class.create(address: address1)
+      described_class.create(address: address2)
+      described_class.create(address: address3)
+      described_class.create(address: '4.4.4.4')
+    end
+
+    it "must query all IP addresses that are in between the first and last IP address" do
+      ip_addresses = subject.in_range(range)
+
+      expect(ip_addresses.length).to eq(3)
+      expect(ip_addresses).to all(be_kind_of(described_class))
+      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 { described_class.destroy_all }
+  end
+
+  describe ".with_mac_address" do
+    subject { described_class }
+
+    let(:mac_address) { '00:01:02:03:04:05' }
+
+    before do
+      ip_address = subject.create(address: address)
+      ip_address.mac_addresses.create(address: mac_address)
+    end
+
+    it "must query all #{described_class} with the associated MAC address" do
+      ip_addresses = subject.with_mac_address(mac_address)
+      expect(ip_addresses.count).to eq(1)
+
+      ip_address = ip_addresses.first
+      expect(ip_address.mac_addresses.first.address).to eq(mac_address)
+    end
+
+    after do
+      Ronin::DB::IPAddressMACAddress.destroy_all
+      Ronin::DB::IPAddress.destroy_all
+      Ronin::DB::MACAddress.destroy_all
+    end
+  end
+
+  describe ".with_host_name" do
+    subject { described_class }
+
+    let(:host) { 'example.com' }
+
+    before do
+      ip_address = subject.create(address: address)
+      ip_address.host_names.create(name: host)
+    end
+
+    it "must query all #{described_class} with the associated host name" do
+      ip_addresses = subject.with_host_name(host)
+      expect(ip_addresses.count).to eq(1)
+
+      ip_address = ip_addresses.first
+      expect(ip_address.host_names.first.name).to eq(host)
+    end
+
+    after do
+      Ronin::DB::HostNameIPAddress.destroy_all
+      Ronin::DB::IPAddress.destroy_all
+      Ronin::DB::HostName.destroy_all
+    end
+  end
+
+  describe ".with_port_number" do
+    subject { described_class }
+
+    let(:port) { 443 }
+
+    before do
+      ip_address = subject.create(address: address)
+      ip_address.ports.create(protocol: :tcp, number: 80)
+      ip_address.ports.create(protocol: :tcp, number: port)
+      ip_address.ports.create(protocol: :tcp, number: 8080)
+    end
+
+    it "must query all #{described_class} with the associated port number" do
+      ip_addresses = subject.with_port_number(port)
+      expect(ip_addresses.count).to eq(1)
+
+      ip_address = ip_addresses.first
+      expect(ip_address.ports[1].number).to eq(port)
+    end
+
+    after do
+      Ronin::DB::OpenPort.destroy_all
+      Ronin::DB::IPAddress.destroy_all
+      Ronin::DB::Port.destroy_all
+    end
+  end
+
+  describe ".lookup" do
+    before do
+      described_class.create(address: '1.2.4.5')
+      described_class.create(address: address)
+      described_class.create(address: '6.7.8.9')
+    end
+
+    it "must query the #{described_class} with the matching IP address" do
+      ip_address = described_class.lookup(address)
+
+      expect(ip_address).to be_kind_of(described_class)
+      expect(ip_address.address).to eq(address)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".import" do
+    subject { described_class.import(address) }
+
+    it "must parse and import the IP address and set #address" do
+      expect(subject).to be_kind_of(described_class)
+      expect(subject.id).to_not be(nil)
+      expect(subject.address).to eq(address)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe "#ipaddr" do
+    it "must automatically parse #address and return an IPAddr" do
+      expect(subject.ipaddr).to be_kind_of(IPAddr)
+      expect(subject.ipaddr.to_s).to eq(address)
+    end
+
+    context "when the address is an IPv4 address" do
+      let(:address) { ipv4_address }
+
+      it "must return an IPv4 IPAddr" do
+        expect(subject.ipaddr.ipv4?).to be(true)
+      end
+    end
+
+    context "when the address is an IPv6 address" do
+      let(:address) { ipv6_address }
+
+      it "must return an IPv6 IPAddr" do
+        expect(subject.ipaddr.ipv6?).to be(true)
+      end
+    end
+
+    context "when the address is not a valid IP address" do
+      let(:address) { '0' }
+
+      it "must return nil" do
+        expect(subject.ipaddr).to be(nil)
+      end
+    end
+  end
+
+  describe "#version" do
+    it "should only accept 4 or 6" do
+      ip_address = described_class.new(address: '1.1.1.1', version: 7)
+
+      expect(ip_address).not_to be_valid
+    end
+
+    context "with IPv4 address" do
+      subject { described_class.new(address: '127.0.0.1') }
+
+      it { expect(subject.version).to be == 4 }
+    end
+
+    context "with IPv6 address" do
+      subject { described_class.new(address: '::1') }
+
+      it { expect(subject.version).to be == 6 }
+    end
+  end
+
+  describe "#asn" do
+    let(:asn_version)      { 4 }
+    let(:asn_range_start)  { '4.0.0.0' }
+    let(:asn_range_end)    { '4.7.168.255' }
+    let(:asn_number)       { 3356 }
+    let(:asn_country_code) { 'US' }
+    let(:asn_name)         { 'LEVEL3' }
+
+    before do
+      Ronin::DB::ASN.create(
+        version:      6,
+        range_start:  '64:ff9b::1:0:0',
+        range_end:    '100::ffff:ffff:ffff:ffff',
+        number:       0
+      )
+
+      Ronin::DB::ASN.create(
+        version:      asn_version,
+        range_start:  asn_range_start,
+        range_end:    asn_range_end,
+        number:       asn_number,
+        country_code: asn_country_code,
+        name:         asn_name
+      )
+
+      Ronin::DB::ASN.create(
+        version:      6,
+        range_start:  '::',
+        range_end:    '::1',
+        number:       0
+      )
+    end
+
+    let(:version) { 4 }
+    let(:address) { '4.4.4.4' }
+
+    subject do
+      described_class.new(
+        version: version,
+        address: address
+      )
+    end
+
+    it "must lookup the ASN record containing the IP address" do
+      asn = subject.asn
+
+      expect(asn).to be_kind_of(Ronin::DB::ASN)
+      expect(asn.version).to eq(version)
+      expect(asn.range_start).to eq('4.0.0.0')
+      expect(asn.range_end).to eq('4.7.168.255')
+    end
+
+    after do
+      Ronin::DB::ASN.destroy_all
+    end
+  end
+
+  describe "#recent_mac_address" do
+  end
+
+  describe "#recent_host_name" do
+  end
+
+  describe "#recent_os_guess" do
+  end
+
+  describe "#save" do
+    subject { described_class.create(address: address) }
+
+    it "must set hton" do
+      expect(subject.hton).to eq(subject.ipaddr.hton)
+    end
+
+    after { subject.destroy }
+  end
+
+  describe "#to_ip" do
+  end
+
+  describe "#to_i" do
+  end
+end

data/spec/mac_address_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'ronin/db/mac_address'
+
+describe Ronin::DB::MACAddress do
+  it "must use the 'ronin_mac_addresses' table" do
+    expect(described_class.table_name).to eq('ronin_mac_addresses')
+  end
+
+  let(:address) { '00:01:02:03:04:05' }
+
+  subject { described_class.new(address: address) }
+
+  describe "validations" do
+    describe "address" do
+      it "should require an address" do
+        mac_address = described_class.new
+        expect(mac_address).not_to be_valid
+        expect(mac_address.errors[:address]).to include(
+          "can't be blank"
+        )
+
+        mac_address = described_class.new(address: address)
+        expect(mac_address).to be_valid
+      end
+    end
+  end
+
+  describe ".lookup" do
+    before do
+      described_class.create(address: '11:12:13:14:15:16')
+      described_class.create(address: address)
+      described_class.create(address: '21:22:23:24:25:26')
+    end
+
+    it "must query the #{described_class} with the matching MAC address" do
+      ip_address = described_class.lookup(address)
+
+      expect(ip_address).to be_kind_of(described_class)
+      expect(ip_address.address).to eq(address)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".import" do
+    subject { described_class.import(address) }
+
+    it "must parse and import the MAC address and set #address" do
+      expect(subject).to be_kind_of(described_class)
+      expect(subject.id).to_not be(nil)
+      expect(subject.address).to eq(address)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe "#recent_ip_address" do
+  end
+
+  describe "#to_i" do
+    let(:integer) { 0x000102030405 }
+
+    it "should convert the MAC Address to an Integer" do
+      expect(subject.to_i).to eq(integer)
+    end
+  end
+end

data/spec/migrations_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'ronin/db/migrations'
+
+describe Ronin::DB::Migrations do
+  let(:migration_context) { subject.send(:context) }
+
+  describe ".current_version" do
+    it "must call .current_version on the MigrationContext object" do
+      expect(migration_context).to receive(:current_version)
+
+      subject.current_version
+    end
+  end
+
+  describe ".needs_migration?" do
+    it "must call .needs_migration? on the MigrationContext object" do
+      expect(migration_context).to receive(:needs_migration?)
+
+      subject.needs_migration?
+    end
+  end
+
+  describe ".migrate" do
+    context "when called with no arguments" do
+      it "must call .migrate(nil) on the MigrationContext object" do
+        expect(migration_context).to receive(:migrate).with(nil)
+
+        subject.migrate
+      end
+    end
+
+    context "when given a target version" do
+      let(:target_version) { 42 }
+
+      it "must call .migrate(target_version) on the MigrationContext object" do
+        expect(migration_context).to receive(:migrate).with(target_version)
+
+        subject.migrate(target_version)
+      end
+    end
+  end
+
+  describe ".up" do
+    context "when called with no arguments" do
+      it "must call .up(nil) on the MigrationContext object" do
+        expect(migration_context).to receive(:up).with(nil)
+
+        subject.up
+      end
+    end
+
+    context "when given a target version" do
+      let(:target_version) { 42 }
+
+      it "must call .up(target_version) on the MigrationContext object" do
+        expect(migration_context).to receive(:up).with(target_version)
+
+        subject.up(target_version)
+      end
+    end
+  end
+
+  describe ".down" do
+    context "when called with no arguments" do
+      it "must call .down(nil) on the MigrationContext object" do
+        expect(migration_context).to receive(:down).with(nil)
+
+        subject.down
+      end
+    end
+
+    context "when given a target version" do
+      let(:target_version) { 42 }
+
+      it "must call .down(target_version) on the MigrationContext object" do
+        expect(migration_context).to receive(:down).with(target_version)
+
+        subject.down(target_version)
+      end
+    end
+  end
+
+  describe ".rollback" do
+    context "when called with no arguments" do
+      it "must call .rollback(1) on the MigrationContext object" do
+        expect(migration_context).to receive(:rollback).with(1)
+
+        subject.rollback
+      end
+    end
+
+    context "when given a target version" do
+      let(:steps) { 2 }
+
+      it "must call .rollback(steps) on the MigrationContext object" do
+        expect(migration_context).to receive(:rollback).with(steps)
+
+        subject.rollback(steps)
+      end
+    end
+  end
+
+  describe ".foreward" do
+    context "when called with no arguments" do
+      it "must call .foreward(1) on the MigrationContext object" do
+        expect(migration_context).to receive(:foreward).with(1)
+
+        subject.foreward
+      end
+    end
+
+    context "when given a target version" do
+      let(:steps) { 2 }
+
+      it "must call .foreward(steps) on the MigrationContext object" do
+        expect(migration_context).to receive(:foreward).with(steps)
+
+        subject.foreward(steps)
+      end
+    end
+  end
+end

data/spec/model/has_name_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'ronin/db/model/has_name'
+
+describe Ronin::DB::Model::HasName do
+  class TestModelHasName < ActiveRecord::Base
+    include Ronin::DB::Model::HasName
+
+    self.table_name = 'test_model_has_name'
+  end
+
+  let(:model) { TestModelHasName }
+
+  before(:all) do
+    ActiveRecord::Base.connection.create_table :test_model_has_name do |t|
+      t.string :name
+    end
+  end
+
+  describe ".included" do
+    subject { model }
+
+    it "should include Ronin::DB::Model" do
+      expect(subject.ancestors).to include(Ronin::DB::Model)
+    end
+
+    it "should define a name attribute" do
+      expect(subject.new).to respond_to(:name)
+      expect(subject.new).to respond_to(:name=)
+    end
+  end
+
+  describe "validations" do
+    subject { model }
+
+    it "should require a name" do
+      resource = subject.new
+      expect(resource).not_to be_valid
+
+      resource.name = 'foo'
+      expect(resource).to be_valid
+    end
+  end
+
+  describe ".named" do
+    subject { model }
+
+    let(:name1) { 'foo1' }
+    let(:name2) { 'foo2' }
+
+    before do
+      subject.create(name: name1)
+      subject.create(name: name2)
+    end
+
+    it "should be able to find resources with similar names" do
+      resources = subject.named('foo')
+
+      expect(resources.length).to eq(2)
+      expect(resources[0].name).to be == name1
+      expect(resources[1].name).to be == name2
+    end
+
+    after { subject.destroy_all }
+  end
+end

data/spec/model/has_unique_name_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'ronin/db/model/has_unique_name'
+
+describe Ronin::DB::Model::HasUniqueName do
+  class TestModelHasUniqueName < ActiveRecord::Base
+    include Ronin::DB::Model::HasUniqueName
+
+    self.table_name = 'test_model_has_unique_name'
+  end
+
+  let(:model) { TestModelHasUniqueName }
+
+  before(:all) do
+    ActiveRecord::Base.connection.create_table :test_model_has_unique_name do |t|
+      t.string :name
+    end
+  end
+
+  describe ".included" do
+    subject { model }
+
+    it "should include Ronin::DB::Model" do
+      expect(subject.ancestors).to include(Ronin::DB::Model)
+    end
+
+    it "should include Ronin::DB::Model::HasName::InstanceMethods" do
+      expect(subject.ancestors).to include(Ronin::DB::Model::HasName::InstanceMethods)
+    end
+
+    it "should define a name attribute" do
+      expect(subject.new).to respond_to(:name)
+      expect(subject.new).to respond_to(:name=)
+    end
+  end
+
+  describe "validations" do
+    subject { model }
+
+    it "should require a name" do
+      record = subject.new
+      expect(record).to_not be_valid
+
+      record.name = 'foo'
+      expect(record).to be_valid
+    end
+
+    context "when the given name already exists in the table" do
+      let(:name) { 'foo' }
+
+      before { model.create(name: name) }
+
+      it "must require a unique name" do
+        record = subject.new(name: name)
+
+        expect(record).to_not be_valid
+      end
+
+      after { model.destroy_all }
+    end
+  end
+end