ronin-db-activerecord 0.1.0.beta1

data/spec/software_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'ronin/db/software'
+
+describe Ronin::DB::Software do
+  it "must use the 'ronin_softwares' table" do
+    expect(described_class.table_name).to eq('ronin_softwares')
+  end
+
+  let(:name)    { 'Test'  }
+  let(:version) { '0.1.0' }
+  let(:vendor)  { 'TestCo' }
+
+  describe "validations" do
+    describe "nmae" do
+      it "must require name attribute" do
+        software = described_class.new(version: version)
+        expect(software).to_not be_valid
+        expect(software.errors[:name]).to eq(
+          ["can't be blank"]
+        )
+
+        software = described_class.new(name: name, version: version)
+        expect(software).to be_valid
+      end
+    end
+
+    describe "version" do
+      it "should require version attribute" do
+        software = described_class.new(name: name)
+        expect(software).to_not be_valid
+        expect(software.errors[:version]).to eq(
+          ["can't be blank"]
+        )
+
+        software = described_class.new(name: name, version: version)
+        expect(software).to be_valid
+      end
+    end
+
+    it "the name and version attributes must be unique" do
+      described_class.create(name: name, version: version)
+
+      software = described_class.new(name: name, version: version)
+      expect(software).to_not be_valid
+      expect(software.errors[:version]).to eq(
+        ['has already been taken']
+      )
+
+      described_class.destroy_all
+    end
+  end
+
+  subject do
+    described_class.new(
+      name:    name,
+      version: version,
+      vendor:  Ronin::DB::SoftwareVendor.new(name: vendor)
+    )
+  end
+
+  describe "#to_s" do
+    it "should be convertable to a String" do
+      expect(subject.to_s).to eq("#{vendor} #{name} #{version}")
+    end
+
+    context "without a vendor" do
+      subject do
+        described_class.new(name: name, version: version)
+      end
+
+      it "should ignore the missing vendor information" do
+        expect(subject.to_s).to eq("#{name} #{version}")
+      end
+    end
+  end
+end

data/spec/software_vendor_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'ronin/db/software_vendor'
+
+describe Ronin::DB::SoftwareVendor do
+  it "must use the 'ronin_software_vendors' table" do
+    expect(described_class.table_name).to eq('ronin_software_vendors')
+  end
+
+  let(:name) { 'TestCo' }
+
+  describe "validations" do
+    describe "name" do
+      it "should require name attribute" do
+        software_vendor = described_class.new
+        expect(software_vendor).to_not be_valid
+        expect(software_vendor.errors[:name]).to eq(
+          ["can't be blank"]
+        )
+
+        software_vendor = described_class.new(name: name)
+        expect(software_vendor).to be_valid
+      end
+    end
+  end
+
+  subject { described_class.new(name: name) }
+
+  describe "#to_s" do
+    it "should include the vendor name" do
+      expect(subject.to_s).to eq(name)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'rspec'
+
+require 'active_record'
+ActiveRecord::Base.establish_connection(
+  adapter: 'sqlite3',
+  database: ':memory:'
+)
+
+require 'ronin/db/migrations'
+Ronin::DB::Migrations.migrate
+
+require 'simplecov'
+SimpleCov.start

data/spec/url_query_param_name_spec.rb

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

data/spec/url_query_param_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'ronin/db/url_query_param'
+
+describe Ronin::DB::URLQueryParam do
+  it "must use the 'ronin_url_query_params' table" do
+    expect(described_class.table_name).to eq('ronin_url_query_params')
+  end
+
+  let(:scheme) { 'https' }
+  let(:host_name) { 'www.example.com' }
+  let(:port) { 8080 }
+  let(:path) { '/path' }
+  let(:query_params) { {'q' => '1'} }
+  let(:query_string) { 'q=1' }
+  let(:fragment) { 'frag' }
+
+  let(:url_scheme) do
+    Ronin::DB::URLScheme.find_or_initialize_by(name: scheme)
+  end
+  let(:url_host_name) do
+    Ronin::DB::HostName.find_or_initialize_by(name: host_name)
+  end
+  let(:url_port) do
+    Ronin::DB::Port.find_or_initialize_by(protocol: :tcp, number: port)
+  end
+  let(:url_query_param_name) do
+    Ronin::DB::URLQueryParamName.find_or_initialize_by(name: name)
+  end
+
+  let(:url) do
+    Ronin::DB::URL.new(
+      scheme:       url_scheme,
+      host_name:    url_host_name,
+      port:         url_port,
+      path:         path,
+      fragment:     fragment
+    )
+  end
+
+  let(:name)  { 'foo' }
+  let(:value) { 'bar' }
+
+  describe "validations" do
+    describe "name" do
+      it "must require a name association" do
+        url_query_param = described_class.new(value: value)
+        expect(url_query_param).to_not be_valid
+        expect(url_query_param.errors[:name]).to eq(
+          ["must exist"]
+        )
+
+        url_query_param = described_class.new(
+          name:  url_query_param_name,
+          value: value,
+          url:   url
+        )
+        expect(url_query_param).to be_valid
+      end
+    end
+
+    describe "url" do
+    end
+  end
+
+  subject do
+    described_class.new(
+      name:  Ronin::DB::URLQueryParamName.new(name: name),
+      value: value,
+      url:   url
+    )
+  end
+
+  describe "#to_s" do
+    it "should dump a name and a value into a String" do
+      expect(subject.to_s).to eq("#{name}=#{value}")
+    end
+
+    context "when an empty value" do
+      let(:value) { '' }
+
+      it "should ignore empty or nil values" do
+        expect(subject.to_s).to eq("#{name}=")
+      end
+    end
+
+    context "when a nil value" do
+      let(:value) { nil }
+
+      it "should ignore empty or nil values" do
+        expect(subject.to_s).to eq("#{name}=")
+      end
+    end
+
+    context "with special characters" do
+      let(:value)         { 'bar baz'         }
+      let(:encoded_value) { URI::DEFAULT_PARSER.escape(value) }
+
+      subject do
+        described_class.new(
+          name:  Ronin::DB::URLQueryParamName.new(name: name),
+          value: value
+        )
+      end
+
+      it "should escape special characters" do
+        expect(subject.to_s).to eq("#{name}=#{encoded_value}")
+      end
+    end
+  end
+end

data/spec/url_scheme_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'ronin/db/url_scheme'
+
+describe Ronin::DB::URLScheme do
+  it "must use the 'ronin_url_schemes' table" do
+    expect(described_class.table_name).to eq('ronin_url_schemes')
+  end
+
+  let(:name) { 'http' }
+
+  describe "validations" do
+    describe "name" do
+      subject { described_class.new(name: 'http') }
+
+      it "must require a name attribute" do
+        url_scheme = described_class.new
+        expect(url_scheme).to_not be_valid
+        expect(url_scheme.errors[:name]).to eq(
+          ["can't be blank"]
+        )
+
+        url_scheme = described_class.new(name: name)
+        expect(url_scheme).to be_valid
+      end
+
+      it "msst require a unique name" do
+        described_class.create(name: name)
+
+        url_scheme = described_class.new(name: name)
+        expect(url_scheme).to_not be_valid
+        expect(url_scheme.errors[:name]).to eq(
+          ["has already been taken"]
+        )
+
+        described_class.destroy_all
+      end
+    end
+  end
+end