ronin-db-activerecord 0.1.0.beta1

data/spec/email_address_spec.rb

@@ -0,0 +1,372 @@
+require 'spec_helper'
+require 'ronin/db/email_address'
+
+describe Ronin::DB::EmailAddress do
+  it "must use the 'ronin_email_addresses' table" do
+    expect(described_class.table_name).to eq('ronin_email_addresses')
+  end
+
+  let(:user)    { 'joe'             }
+  let(:host)    { 'example.com'     }
+  let(:address) { "#{user}@#{host}" }
+
+  let(:user_name) { Ronin::DB::UserName.new(name: user) }
+  let(:host_name) { Ronin::DB::HostName.new(name: host) }
+
+  subject do
+    described_class.new(
+      user_name: user_name,
+      host_name: host_name
+    )
+  end
+
+  describe "validations" do
+    describe "address" do
+      it "must require an email address" do
+        email_address = described_class.new(
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:address]).to include(
+          "can't be blank"
+        )
+
+        email_address = described_class.new(
+          address: address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+      end
+
+      it "must require a valid email address" do
+        email_address = described_class.new(
+          address: "foo AT bar DOT com",
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:address]).to eq(
+          ["Must be a valid email address"]
+        )
+
+        email_address = described_class.new(
+          address: address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+      end
+
+      it "must not allow email addresses longer than 320 characters" do
+        email_address = described_class.new(
+          address: ('a' * 320) + "@example.com",
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:address]).to eq(
+          ["is too long (maximum is 320 characters)"]
+        )
+
+        email_address = described_class.new(
+          address: address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+      end
+
+      it "must require a unique email address" do
+        user_name.save
+        host_name.save
+
+        email_address = described_class.create(
+          address:   address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+
+        email_address = described_class.new(
+          address:   address,
+          user_name: user_name,
+          host_name: host_name
+        )
+
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:address]).to eq(
+          ["has already been taken"]
+        )
+
+        described_class.destroy_all
+        user_name.destroy
+        host_name.destroy
+      end
+    end
+
+    describe "host_name" do
+      it "must require a host_name" do
+        email_address = described_class.new(
+          address: address,
+          user_name: user_name
+        )
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:host_name]).to include(
+          "must exist"
+        )
+
+        email_address = described_class.new(
+          address:   address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+      end
+    end
+
+    describe "user_name" do
+      it "must require a user_name" do
+        email_address = described_class.new(
+          address: address,
+          host_name: host_name
+        )
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:user_name]).to include(
+          "must exist"
+        )
+
+        email_address = described_class.new(
+          address:   address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+      end
+
+      it "must require a unique combination of host_name and user_name" do
+        user_name.save
+        host_name.save
+
+        email_address = described_class.create(
+          address:   address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to be_valid
+
+        email_address = described_class.new(
+          address:   address,
+          user_name: user_name,
+          host_name: host_name
+        )
+        expect(email_address).to_not be_valid
+        expect(email_address.errors[:user_name]).to eq(
+          ["has already been taken"]
+        )
+
+        described_class.destroy_all
+        user_name.destroy
+        host_name.destroy
+      end
+    end
+  end
+
+  describe ".with_host_name" do
+    subject { described_class }
+
+    let(:user_name) { Ronin::DB::UserName.create(name: user) }
+    let(:host_name) { Ronin::DB::HostName.create(name: host) }
+
+    before do
+      email_address = described_class.create(
+        address:   address,
+        user_name: user_name,
+        host_name: host_name
+      )
+    end
+
+    it "must find the #{described_class} with the associated host name" do
+      email_address = subject.with_host_name(host).first
+
+      expect(email_address).to be_kind_of(described_class)
+      expect(email_address.host_name.name).to eq(host)
+    end
+
+    after do
+      described_class.destroy_all
+      user_name.destroy
+      host_name.destroy
+    end
+  end
+
+  describe ".with_ip_address" do
+    subject { described_class }
+
+    let(:user_name) { Ronin::DB::UserName.create(name: user) }
+    let(:host_name) { Ronin::DB::HostName.create(name: host) }
+
+    let(:ip) { '93.184.216.34' }
+    let(:ip_address) { Ronin::DB::IPAddress.create(address: ip) }
+
+    before do
+      email_address = described_class.create(
+        address:   address,
+        user_name: user_name,
+        host_name: host_name
+      )
+      email_address.host_name.ip_addresses << ip_address
+    end
+
+    it "must find the #{described_class} with the associated IP address" do
+      email_address = subject.with_ip_address(ip).first
+
+      expect(email_address).to be_kind_of(described_class)
+      expect(email_address.ip_addresses.first.address).to eq(ip)
+    end
+
+    after do
+      described_class.destroy_all
+      ip_address.destroy
+      user_name.destroy
+      host_name.destroy
+    end
+  end
+
+  describe ".with_user_name" do
+    subject { described_class }
+
+    let(:user_name) { Ronin::DB::UserName.create(name: user) }
+    let(:host_name) { Ronin::DB::HostName.create(name: host) }
+
+    before do
+      email_address = described_class.create(
+        address:   address,
+        user_name: user_name,
+        host_name: host_name
+      )
+    end
+
+    it "must find the #{described_class} with the associated user name" do
+      email_address = subject.with_user_name(user).first
+
+      expect(email_address).to be_kind_of(described_class)
+      expect(email_address.user_name.name).to eq(user)
+    end
+
+    after do
+      described_class.destroy_all
+      user_name.destroy
+      host_name.destroy
+    end
+  end
+
+  describe ".lookup" do
+    let(:user_name) { Ronin::DB::UserName.create(name: user) }
+    let(:host_name) { Ronin::DB::HostName.create(name: host) }
+
+    before do
+      described_class.create(
+        address: 'other_user1@other_host1.com',
+        user_name: Ronin::DB::UserName.create(name: 'other_user1'),
+        host_name: Ronin::DB::HostName.create(name: 'other_host1')
+      )
+
+      described_class.create(
+        address:   address,
+        user_name: user_name,
+        host_name: host_name
+      )
+
+      described_class.create(
+        address: 'other_user2@other_host2.com',
+        user_name: Ronin::DB::UserName.create(name: 'other_user2'),
+        host_name: Ronin::DB::HostName.create(name: 'other_host2')
+      )
+    end
+
+    it "must query the #{described_class} with the given address" do
+      email_address = described_class.lookup(address)
+
+      expect(email_address.address).to eq(address)
+    end
+
+    after do
+      described_class.destroy_all
+      user_name.destroy
+      host_name.destroy
+    end
+  end
+
+  describe ".import" do
+    context "when given a valid email address" do
+      subject { described_class.import(address) }
+
+      it "must parse and import the email address" do
+        expect(subject.user_name.name).to eq(user)
+        expect(subject.host_name.name).to eq(host)
+      end
+
+      after do
+        subject.destroy
+        subject.user_name.destroy
+        subject.host_name.destroy
+      end
+    end
+
+    context "when the email address does not have a user name" do
+      subject { described_class }
+
+      let(:address) { "@#{host}" }
+
+      it do
+        expect {
+          subject.import(address)
+        }.to raise_error(ArgumentError,"email address #{address.inspect} must have a user name")
+      end
+    end
+
+    context "when the email address does not have a host name" do
+      subject { described_class }
+
+      let(:address) { "#{user}@" }
+
+      it do
+        expect {
+          subject.import(address)
+        }.to raise_error(ArgumentError,"email address #{address.inspect} must have a host name")
+      end
+    end
+
+    context "when the email address contains spaces" do
+      subject { described_class }
+
+      let(:address) { "#{user} @ #{host}" }
+
+      it do
+        expect {
+          subject.import(address)
+        }.to raise_error(ArgumentError,"email address #{address.inspect} must not contain spaces")
+      end
+    end
+  end
+
+  describe "#user" do
+    it "must return the user-name" do
+      expect(subject.user).to eq(user)
+    end
+  end
+
+  describe "#host" do
+    it "must return the host-name" do
+      expect(subject.host).to eq(host)
+    end
+  end
+
+  describe "#to_s" do
+    it "should include the email address" do
+      expect(subject.to_s).to eq(address)
+    end
+  end
+end

data/spec/host_name_ip_address_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+require 'ronin/db/host_name_ip_address'
+
+describe Ronin::DB::HostNameIPAddress do
+  it "must use the 'ronin_host_name_ip_addresses' table" do
+    expect(described_class.table_name).to eq('ronin_host_name_ip_addresses')
+  end
+end

data/spec/host_name_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+require 'ronin/db/host_name'
+
+describe Ronin::DB::HostName do
+  it "must use the 'ronin_host_names' table" do
+    expect(described_class.table_name).to eq('ronin_host_names')
+  end
+
+  it "must include Ronin::DB::Model::LastScannedat" do
+    expect(described_class).to include(Ronin::DB::Model::LastScannedAt)
+  end
+
+  let(:name)    { 'example.com'   }
+  let(:address) { '93.184.216.34' }
+
+  describe "validations" do
+    describe "name" do
+      it "require an host name" do
+        host_name = described_class.new
+        expect(host_name).to_not be_valid
+
+        host_name = described_class.new(name: name)
+        expect(host_name).to be_valid
+      end
+
+      it "must require a unique name" do
+        described_class.create(name: name)
+
+        host_name = described_class.new(name: name)
+        expect(host_name).to_not be_valid
+
+        described_class.destroy_all
+      end
+    end
+  end
+
+  describe ".with_ip_address" do
+    subject { described_class }
+
+    let(:name)    { 'example.com'   }
+    let(:address) { '93.184.216.34' }
+
+    before do
+      host = subject.create(name: name)
+      host.ip_addresses.create(address: address)
+    end
+
+    it "must find the #{described_class} with the associated IP address" do
+      host = subject.with_ip_address([address]).first
+
+      expect(host).to be_kind_of(described_class)
+      expect(host.name).to eq(name)
+      expect(host.ip_addresses[0].address).to eq(address)
+    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(:port1) { 80  }
+    let(:port2) { 443 }
+    let(:ports) { [port1, port2] }
+
+    before do
+      host       = described_class.create(name: name)
+      ip_address = host.ip_addresses.create(address: address)
+
+      ip_address.ports.create(protocol: :tcp, number: port1)
+      ip_address.ports.create(protocol: :tcp, number: port2)
+    end
+
+    it "must find the #{described_class} with the associated port number" do
+      host = subject.with_port_number(port2).first
+
+      expect(host).to be_kind_of(described_class)
+      expect(host.name).to eq(name)
+      expect(host.ports.map(&:number)).to include(port2)
+    end
+
+    context "when given an Array of port numbers" do
+      it "must find the #{described_class} with the associated port numbers" do
+        host = subject.with_port_number(ports).first
+
+        expect(host).to be_kind_of(described_class)
+        expect(host.name).to eq(name)
+        expect(host.ports[0].number).to eq(port1)
+        expect(host.ports[1].number).to eq(port2)
+      end
+    end
+
+    after do
+      Ronin::DB::OpenPort.destroy_all
+      Ronin::DB::Port.destroy_all
+      Ronin::DB::HostNameIPAddress.destroy_all
+      Ronin::DB::IPAddress.destroy_all
+      Ronin::DB::HostName.destroy_all
+    end
+  end
+
+  describe ".with_tld" do
+    subject { described_class }
+
+    let(:tld)    { 'co.uk' }
+    let(:domain) { "example.#{tld}" }
+
+    before do
+      subject.create(name: domain)
+    end
+
+    it "must find the #{described_class} with the given TLD" do
+      host_name = subject.with_tld(tld).first
+
+      expect(host_name).to be_kind_of(described_class)
+      expect(host_name.name).to eq(domain)
+    end
+
+    after do
+      described_class.destroy_all
+    end
+  end
+
+  describe ".with_domain" do
+    subject { described_class }
+
+    context "when the exact domain exists in the database" do
+      let(:domain) { 'example.com' }
+
+      before do
+        subject.create(name: domain)
+      end
+
+      it "must query the domain" do
+        host = subject.with_domain(domain).first
+
+        expect(host).to be_kind_of(described_class)
+        expect(host.name).to eq(domain)
+      end
+
+      after { subject.destroy_all }
+
+      context "when other sub-domain names exist in the database" do
+        let(:sub_domain1) { 'www.example.com'  }
+        let(:sub_domain2) { 'mail.example.com' }
+
+        before do
+          subject.create(name: sub_domain1)
+          subject.create(name: sub_domain2)
+        end
+
+        it "must query the domain and sub-domain names" do
+          hosts = subject.with_domain(domain)
+
+          expect(hosts[0]).to be_kind_of(described_class)
+          expect(hosts[0].name).to eq(domain)
+
+          expect(hosts[1]).to be_kind_of(described_class)
+          expect(hosts[1].name).to eq(sub_domain1)
+
+          expect(hosts[2]).to be_kind_of(described_class)
+          expect(hosts[2].name).to eq(sub_domain2)
+        end
+
+        after { subject.destroy_all }
+      end
+    end
+  end
+
+  describe ".lookup" do
+    before do
+      described_class.create(name: 'other.host1.com')
+      described_class.create(name: name)
+      described_class.create(name: 'other.host2.com')
+    end
+
+    it "must query the #{described_class} with the matching name" do
+      host_name = described_class.lookup(name)
+
+      expect(host_name).to be_kind_of(described_class)
+      expect(host_name.name).to eq(name)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe ".import" do
+    let(:name) { 'example.com' }
+
+    subject { described_class.import(name) }
+
+    it "must import the host name and return a new #{described_class} record" do
+      expect(subject).to be_kind_of(described_class)
+      expect(subject.id).to_not be(nil)
+      expect(subject.name).to eq(name)
+    end
+
+    after { described_class.destroy_all }
+  end
+
+  describe "#recent_ip_address" do
+  end
+end

data/spec/http_header_name_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'ronin/db/http_header_name'
+
+describe Ronin::DB::HTTPHeaderName do
+  it "must use the 'ronin_http_header_names' table" do
+    expect(described_class.table_name).to eq('ronin_http_header_names')
+  end
+
+  let(:name) { 'foo' }
+
+  describe "validations" do
+    describe "name" do
+      it "should require name attribute" do
+        http_header_name = described_class.new
+        expect(http_header_name).to_not be_valid
+        expect(http_header_name.errors[:name]).to eq(
+          ["can't be blank"]
+        )
+
+        http_header_name = described_class.new(name: name)
+        expect(http_header_name).to be_valid
+      end
+    end
+  end
+end

data/spec/http_query_param_name_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'ronin/db/http_query_param_name'
+
+describe Ronin::DB::HTTPQueryParamName do
+  it "must use the 'ronin_http_query_param_names' table" do
+    expect(described_class.table_name).to eq('ronin_http_query_param_names')
+  end
+
+  let(:name) { 'foo' }
+
+  describe "validations" do
+    describe "name" do
+      it "should require name attribute" do
+        http_query_param_name = described_class.new
+        expect(http_query_param_name).to_not be_valid
+        expect(http_query_param_name.errors[:name]).to eq(
+          ["can't be blank"]
+        )
+
+        http_query_param_name = described_class.new(name: name)
+        expect(http_query_param_name).to be_valid
+      end
+    end
+  end
+end