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

data/spec/http_query_param_spec.rb

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

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

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

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

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

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