ronin-db-activerecord 0.1.0.beta1

data/spec/http_query_param_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+require 'ronin/db/http_query_param'
+require 'ronin/db/http_request'
+
+describe Ronin::DB::HTTPQueryParam do
+  it "must use the 'ronin_http_query_params' table" do
+    expect(described_class.table_name).to eq('ronin_http_query_params')
+  end
+
+  let(:name)  { 'foo' }
+  let(:value) { 'bar' }
+
+  let(:http_query_param_name) do
+    Ronin::DB::HTTPQueryParamName.find_or_initialize_by(name: name)
+  end
+
+  let(:request_method) { :get }
+  let(:path)           { '/search' }
+  let(:request) do
+    Ronin::DB::HTTPRequest.new(
+      request_method: request_method,
+      path:           path
+    )
+  end
+
+  describe "validations" do
+    describe "name" do
+      it "must require a name association" do
+        http_query_param = described_class.new(value: value)
+        expect(http_query_param).to_not be_valid
+        expect(http_query_param.errors[:name]).to eq(
+          ["must exist"]
+        )
+
+        http_query_param = described_class.new(
+          name:    http_query_param_name,
+          value:   value,
+          request: request
+        )
+        expect(http_query_param).to be_valid
+      end
+    end
+
+    describe "request" do
+      it "must require a request association" do
+        http_query_param = described_class.new(
+          name:    http_query_param_name,
+          value:   value
+        )
+
+        expect(http_query_param).to_not be_valid
+        expect(http_query_param.errors[:request]).to eq(
+          ['must exist']
+        )
+      end
+    end
+  end
+
+  subject do
+    described_class.new(
+      name:    Ronin::DB::HTTPQueryParamName.new(name: name),
+      value:   value,
+      request: request
+    )
+  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::HTTPQueryParamName.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/http_request_header_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'ronin/db/http_request_header'
+require 'ronin/db/http_request'
+
+describe Ronin::DB::HTTPRequestHeader do
+  it "must use the 'ronin_http_request_headers' table" do
+    expect(described_class.table_name).to eq('ronin_http_request_headers')
+  end
+
+  let(:name)  { 'foo' }
+  let(:value) { 'bar' }
+
+  let(:http_header_name) do
+    Ronin::DB::HTTPHeaderName.find_or_initialize_by(name: name)
+  end
+
+  let(:request_method) { :get }
+  let(:path)           { '/search' }
+  let(:request) do
+    Ronin::DB::HTTPRequest.new(
+      request_method: request_method,
+      path:           path
+    )
+  end
+
+  describe "validations" do
+    describe "name" do
+      it "must require a name association" do
+        http_request_header = described_class.new(value: value)
+        expect(http_request_header).to_not be_valid
+        expect(http_request_header.errors[:name]).to eq(
+          ["must exist"]
+        )
+
+        http_request_header = described_class.new(
+          name:    http_header_name,
+          value:   value,
+          request: request
+        )
+        expect(http_request_header).to be_valid
+      end
+    end
+
+    describe "request" do
+      it "must require a request association" do
+        http_request_header = described_class.new(
+          name:  http_header_name,
+          value: value
+        )
+
+        expect(http_request_header).to_not be_valid
+        expect(http_request_header.errors[:request]).to eq(
+          ['must exist']
+        )
+      end
+    end
+  end
+
+  subject do
+    described_class.new(
+      name:    Ronin::DB::HTTPHeaderName.new(name: name),
+      value:   value,
+      request: request
+    )
+  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
+  end
+end

data/spec/http_request_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+require 'ronin/db/http_request'
+
+describe Ronin::DB::HTTPRequest do
+  it "must use the 'ronin_http_requests' table" do
+    expect(described_class.table_name).to eq('ronin_http_requests')
+  end
+
+  let(:name)  { 'foo' }
+  let(:value) { 'bar' }
+
+  let(:http_header_name) do
+    Ronin::DB::HTTPHeaderName.find_or_initialize_by(name: name)
+  end
+
+  let(:version)        { '1.1' }
+  let(:request_method) { :get }
+  let(:path)           { '/search' }
+
+  subject do
+    described_class.new(
+      version:        version,
+      request_method: request_method,
+      path:           path
+    )
+  end
+
+  describe "validations" do
+    describe "version" do
+      %w[1.0 1.1 2.0].each do |valid_version|
+        it "must accept '#{valid_version}'" do
+          request = described_class.new(
+                      version:        valid_version,
+                      request_method: request_method,
+                      path:           path
+                    )
+
+          expect(request).to be_valid
+        end
+      end
+
+      it "must not accept any other version String" do
+        request = described_class.new(
+                    version:        '3.0',
+                    request_method: request_method,
+                    path:           path
+                  )
+
+        expect(request).to_not be_valid
+        expect(request.errors[:version]).to eq(
+          ["is not included in the list"]
+        )
+      end
+
+      it "must not accept any other String" do
+        request = described_class.new(
+                    version:        'foo',
+                    request_method: request_method,
+                    path:           path
+                  )
+
+        expect(request).to_not be_valid
+        expect(request.errors[:version]).to eq(
+          ["is not included in the list"]
+        )
+      end
+
+      it "must not accept nil" do
+        request = described_class.new(
+                    version:        nil,
+                    request_method: request_method,
+                    path:           path
+                  )
+
+        expect(request).to_not be_valid
+        expect(request.errors[:version]).to eq(
+          ["can't be blank", "is not included in the list"]
+        )
+      end
+    end
+
+    describe "request_method" do
+      [
+        :copy,
+        :delete,
+        :get,
+        :head,
+        :lock,
+        :mkcol,
+        :move,
+        :options,
+        :patch,
+        :post,
+        :propfind,
+        :proppatch,
+        :put,
+        :trace,
+        :unlock
+      ].each do |valid_request_method|
+        it "must accept #{valid_request_method.inspect}" do
+          request = described_class.new(
+                      version:        version,
+                      request_method: valid_request_method,
+                      path:           path
+                    )
+
+          expect(request).to be_valid
+        end
+      end
+
+      it "must not accept any other Symbol" do
+        expect {
+          described_class.new(
+            version:        version,
+            request_method: :foo,
+            path:           path
+          )
+        }.to raise_error(ArgumentError,"'foo' is not a valid request_method")
+      end
+
+      it "must not accept a nil value" do
+        request = described_class.new(
+                    version:        version,
+                    request_method: nil,
+                    path:           path
+                  )
+
+        expect(request).to_not be_valid
+      end
+
+      it "must require a request_method value" do
+        request = described_class.new(
+                    version: version,
+                    path:    path
+                  )
+
+        expect(request).to_not be_valid
+      end
+    end
+
+    describe "path" do
+      it "must require a path" do
+        request = described_class.new(
+                    version:        version,
+                    request_method: request_method
+                  )
+
+        expect(request).to_not be_valid
+        expect(request.errors[:path]).to eq(
+          ["can't be blank"]
+        )
+      end
+
+      it "must require a non-empty path" do
+        request = described_class.new(
+                    version:        version,
+                    request_method: request_method,
+                    path:           ''
+                  )
+
+        expect(request).to_not be_valid
+        expect(request.errors[:path]).to eq(
+          ["can't be blank"]
+        )
+      end
+    end
+  end
+end

data/spec/http_response_header_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'ronin/db/http_response_header'
+require 'ronin/db/http_response'
+
+describe Ronin::DB::HTTPResponseHeader do
+  it "must use the 'ronin_http_response_headers' table" do
+    expect(described_class.table_name).to eq('ronin_http_response_headers')
+  end
+
+  let(:name)  { 'foo' }
+  let(:value) { 'bar' }
+
+  let(:http_header_name) do
+    Ronin::DB::HTTPHeaderName.find_or_initialize_by(name: name)
+  end
+
+  let(:request_method) { :get }
+  let(:path)           { '/search' }
+  let(:request) do
+    Ronin::DB::HTTPRequest.new(
+      request_method: request_method,
+      path:           path,
+      respnse:        response
+    )
+  end
+  let(:response) { Ronin::DB::HTTPResponse.new }
+
+  describe "validations" do
+    describe "name" do
+      it "must require a name association" do
+        http_response_header = described_class.new(value: value)
+        expect(http_response_header).to_not be_valid
+        expect(http_response_header.errors[:name]).to eq(
+          ["must exist"]
+        )
+
+        http_response_header = described_class.new(
+          name:     http_header_name,
+          value:    value,
+          response: response
+        )
+        expect(http_response_header).to be_valid
+      end
+    end
+
+    describe "response" do
+      it "must require a response association" do
+        http_response_header = described_class.new(
+          name:  http_header_name,
+          value: value
+        )
+
+        expect(http_response_header).to_not be_valid
+        expect(http_response_header.errors[:response]).to eq(
+          ['must exist']
+        )
+      end
+    end
+  end
+
+  subject do
+    described_class.new(
+      name:     Ronin::DB::HTTPHeaderName.new(name: name),
+      value:    value,
+      response: response
+    )
+  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
+  end
+end

data/spec/http_response_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'ronin/db/http_response'
+
+describe Ronin::DB::HTTPResponse do
+  it "must use the 'ronin_http_responses' table" do
+    expect(described_class.table_name).to eq('ronin_http_responses')
+  end
+
+  let(:name)  { 'foo' }
+  let(:value) { 'bar' }
+
+  let(:http_header_name) do
+    Ronin::DB::HTTPHeaderName.find_or_initialize_by(name: name)
+  end
+
+  let(:version)        { '1.1' }
+  let(:request_method) { :get }
+  let(:path)           { '/search' }
+
+  let(:request) do
+    Ronin::DB::HTTPRequest.new(
+      version:        version,
+      request_method: request_method,
+      path:           path
+    )
+  end
+
+  let(:status) { 200 }
+  subject do
+    described_class.new(
+      status:  status,
+      request: request
+    )
+  end
+
+  describe "validations" do
+    describe "status" do
+      it "must require a status" do
+        response = described_class.new(request: request)
+
+        expect(response).to_not be_valid
+        expect(response.errors[:status]).to eq(
+          ["can't be blank", "is not included in the list"]
+        )
+      end
+
+      it "must not allow nil" do
+        response = described_class.new(
+                     status:  nil,
+                     request: request
+                   )
+
+        expect(response).to_not be_valid
+        expect(response.errors[:status]).to eq(
+          ["can't be blank", "is not included in the list"]
+        )
+      end
+
+      [
+        100, 101, 103,
+        200, 201, 202, 203, 204, 206, 207, 208, 226,
+        300, 301, 302, 303, 304, 305, 306, 307, 308,
+        400, 401, 402, 403, 404, 405, 406, 407, 408, 409,
+        410, 411, 412, 413, 414, 415, 416, 417, 418,
+        421, 422, 423, 424, 425, 426, 428, 429,
+        431, 451,
+        500, 501, 502, 503, 504, 505, 506, 507, 508, 511
+      ].each do |valid_status|
+        it "must accept #{valid_status}" do
+          response = described_class.new(
+                       status:  valid_status,
+                       request: request
+                     )
+
+          expect(response).to be_valid
+        end
+      end
+
+      it "must not accept any other Integer" do
+        response = described_class.new(
+                     status:  600,
+                     request: request
+                   )
+
+        expect(response).to_not be_valid
+        expect(response.errors[:status]).to eq(
+          ["is not included in the list"]
+        )
+      end
+    end
+
+    describe "request" do
+      it "must require a parent request" do
+        response = described_class.new(status: status)
+
+        expect(response).to_not be_valid
+        expect(response.errors[:request]).to eq(
+          ["must exist"]
+        )
+      end
+    end
+  end
+end

data/spec/ip_address_mac_addresses_spec.rb

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