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

data/spec/email_address_spec.rb

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

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

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

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

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