ronin 1.5.1 → 2.0.0.beta1

data/spec/ip_address_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/ip_address'
-
-describe IPAddress do
-  let(:example_domain) { 'localhost' }
-  let(:example_ip) { '127.0.0.1' }
-
-  subject { described_class.new(:address => example_ip) }
-
-  it "should require an address" do
-    ip_address = described_class.new
-
-    expect(ip_address).not_to be_valid
-  end
-
-  describe "extract" do
-    subject { described_class }
-
-    let(:ip1)  { subject.parse('127.0.0.1') }
-    let(:ip2)  { subject.parse('10.1.1.1') }
-    let(:text) { "Hosts: #{ip1}, #{ip2}" }
-
-    it "should extract multiple IP Addresses from text" do
-      expect(subject.extract(text)).to eq([ip1, ip2])
-    end
-
-    it "should yield the extracted IPs if a block is given" do
-      ip_addresses = []
-
-      subject.extract(text) { |ip| ip_addresses << ip }
-
-      expect(ip_addresses).to eq([ip1, ip2])
-    end
-  end
-
-  describe "lookup" do
-    subject { described_class }
-
-    it "should lookup host-names to IP Addresses" do
-      ip_addresses = subject.lookup(example_domain)
-      addresses    = ip_addresses.map { |ip| ip.address }
-      
-      expect(addresses).to include(example_ip)
-    end
-
-    it "should associate the IP addresses with the original host name" do
-      ip_addresses = subject.lookup(example_domain)
-      host_names   = ip_addresses.map { |ip| ip.host_names[0].address }
-      
-      expect(host_names).to include(example_domain)
-    end
-
-    let(:bad_domain) { 'foo' }
-
-    it "should return an empty Array for unknown domain names" do
-      ip_addresses = subject.lookup(bad_domain)
-      
-      expect(ip_addresses).to be_empty
-    end
-  end
-
-  describe "#lookup!" do
-    it "should reverse lookup the host-name for an IP Address" do
-      host_names = subject.lookup!
-      addresses  = host_names.map { |host_name| host_name.address }
-      
-      expect(addresses).to include(example_domain)
-    end
-
-    it "should associate the host names with the original IP address" do
-      host_names   = subject.lookup!
-      ip_addresses = host_names.map do |host_name|
-        host_name.ip_addresses[0].address
-      end
-
-      expect(ip_addresses).to include(subject)
-    end
-
-    let(:bad_ip) { '0.0.0.0' }
-
-    it "should return an empty Array for unknown domain names" do
-      ip_address = described_class.new(:address => bad_ip)
-      host_names = ip_address.lookup!
-
-      expect(host_names).to be_empty
-    end
-  end
-
-  describe "#version" do
-    it "should only accept 4 or 6" do
-      ip_address = described_class.new(:address => '1.1.1.1', :version => 7)
-
-      expect(ip_address).not_to be_valid
-    end
-
-    context "with IPv4 address" do
-      subject { described_class.new(:address => '127.0.0.1') }
-
-      it { expect(subject.version).to be == 4 }
-    end
-
-    context "with IPv6 address" do
-      subject { described_class.new(:address => '::1') }
-
-      it { expect(subject.version).to be == 6 }
-    end
-  end
-end

data/spec/license_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/license'
-
-describe License do
-  describe "validations" do
-    it "should require name and description attributes" do
-      expect(subject).not_to be_valid
-
-      subject.name = 'joke'
-      expect(subject).not_to be_valid
-
-      subject.description = "yep, it's a joke."
-      expect(subject).to be_valid
-    end
-  end
-
-  describe "predefined licenses" do
-    subject { described_class }
-
-    it "should provide built-in licenses"do
-      expect(subject.cc_by).not_to be_nil
-    end
-  end
-end

data/spec/mac_address_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-require 'ronin/mac_address'
-
-describe MACAddress do
-  let(:address) { '00:01:02:03:04:05' }
-
-  subject { described_class.new(:address => address) }
-
-  describe "extract" do
-    subject { described_class }
-
-    let(:mac1) { subject.parse('00:12:34:56:78:9a') }
-    let(:mac2) { subject.parse('AA:BB:CC:DD:EE:FF') }
-    let(:text)  { "MACs: #{mac1}, #{mac2}." }
-
-    it "should extract multiple MAC Addresses from text" do
-      expect(subject.extract(text)).to eq([mac1, mac2])
-    end
-
-    it "should yield the extracted MAC Addresses if a block is given" do
-      macs = []
-
-      subject.extract(text) { |mac| macs << mac }
-
-      expect(macs).to eq([mac1, mac2])
-    end
-  end
-
-  describe "validations" do
-    it "should require an address" do
-      mac = described_class.new
-      expect(mac).not_to be_valid
-
-      mac.address = address
-      expect(mac).to be_valid
-    end
-  end
-
-  describe "#to_i" do
-    let(:integer) { 0x000102030405 }
-
-    it "should convert the MAC Address to an Integer" do
-      expect(subject.to_i).to eq(integer)
-    end
-  end
-end

data/spec/model/has_authors_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-require 'model/models/authored_model'
-
-require 'ronin/model/has_authors'
-
-describe Model::HasAuthors do
-  let(:model) { AuthoredModel }
-
-  describe ".included" do
-    subject { model }
-
-    it "should include Ronin::Model" do
-      expect(subject.ancestors).to include(Model)
-    end
-
-    it "should define an authors relationship" do
-      relationship = subject.relationships['authors']
-
-      expect(relationship).not_to be_nil
-      expect(relationship.child_model).to eq(Author)
-    end
-
-    it "should define relationships with Author" do
-      relationship = Author.relationships['authored_models']
-
-      expect(relationship).not_to be_nil
-      expect(relationship.child_model).to eq(subject)
-    end
-  end
-
-  let(:author_name) { 'Alice' }
-  let(:author_email) { 'alice@example.com' }
-  let(:organization) { 'Org' }
-
-  describe "#author" do
-    subject do
-      model.new.tap do |resource|
-        resource.author(:name => author_name, :email => author_email)
-      end
-    end
-
-    it "should allow adding authors to a resource" do
-      expect(subject.authors).not_to be_empty
-      expect(subject.authors[0].name).to be(author_name)
-      expect(subject.authors[0].email).to be(author_email)
-    end
-  end
-
-  describe ".written_by" do
-    subject { model }
-
-    before do
-      resource = subject.new(:content => 'Test')
-      resource.author(
-        :name => author_name,
-        :email => author_email,
-        :organization => organization
-      )
-
-      resource.save
-    end
-
-    it "should allow querying resources based on their Author" do
-      resources = subject.written_by(author_name)
-
-      expect(resources.length).to eq(1)
-      expect(resources[0].authors[0].name).to be == author_name
-    end
-
-    it "should allow querying resources based on their Organization" do
-      resources = subject.written_for(organization)
-
-      expect(resources.length).to eq(1)
-      expect(resources[0].authors[0].organization).to be == organization
-    end
-
-    after { subject.destroy }
-  end
-end

data/spec/model/has_description_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-require 'model/models/described_model'
-
-require 'ronin/model/has_description'
-
-describe Model::HasDescription do
-  let(:model) { DescribedModel }
-
-  describe ".included" do
-    subject { model }
-
-    it "should include Ronin::Model" do
-      expect(subject.ancestors).to include(Model)
-    end
-
-    it "should define a description property" do
-      expect(subject.properties).to be_named(:description)
-    end
-  end
-
-  describe "#description" do
-    subject { model.new }
-
-    it "should allow the setting of the description" do
-      subject.description = 'test one'
-      expect(subject.description).to eq('test one')
-    end
-
-    it "should strip leading and tailing white-space" do
-      subject.description = %{   test two    }
-
-      expect(subject.description).to eq('test two')
-    end
-
-    it "should strip leading and tailing white-space from each line" do
-      subject.description = %{
-        test
-        three
-      }
-
-      expect(subject.description).to eq("test\nthree")
-    end
-
-    it "should preserve non-bordering empty lines" do
-      subject.description = %{
-        test
-
-        four
-      }
-
-      expect(subject.description).to eq("test\n\nfour")
-    end
-  end
-
-  describe ".describing" do
-    subject { model }
-
-    let(:description1) { 'foo one' }
-    let(:description2) { 'foo bar two' }
-
-    before do
-      subject.create!(:description => description1)
-      subject.create!(:description => description2)
-    end
-
-    it "should be able to find resources with similar descriptions" do
-      resources = subject.describing('foo')
-
-      expect(resources.length).to be(2)
-      expect(resources[0].description).to be == description1
-      expect(resources[1].description).to be == description2
-    end
-
-    after { subject.destroy }
-  end
-end

data/spec/model/has_license_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-require 'model/models/licensed_model'
-
-require 'ronin/model/has_license'
-
-describe Model::HasLicense do
-  let(:model) { LicensedModel }
-
-  describe ".included" do
-    subject { model }
-
-    it "should include Ronin::Model" do
-      expect(subject.ancestors).to include(Model)
-    end
-
-    it "should define a license relationship" do
-      relationship = subject.relationships['license']
-
-      expect(relationship).not_to be_nil
-      expect(relationship.parent_model).to eq(License)
-    end
-
-    it "should define relationships with License" do
-      relationship = License.relationships['licensed_models']
-
-      expect(relationship).not_to be_nil
-      expect(relationship.child_model).to eq(subject)
-    end
-  end
-
-  describe "validations" do
-    subject { model }
-
-    it "should not require a license" do
-      resource = subject.new(:content => 'bla')
-
-      expect(resource).to be_valid
-    end
-  end
-
-  describe ".licensed_under" do
-    subject { model }
-
-    before do
-      subject.create(
-        :content => 'stuff here',
-        :license => License.gpl2
-      )
-    end
-
-    let(:license) { License.gpl2 }
-
-    it "should accept License resources" do
-      resource = subject.licensed_under(license).first
-
-      expect(resource.license).to be == license
-    end
-
-    it "should accept the names of predefined Licenses" do
-      resource = subject.licensed_under(:gpl2).first
-
-      expect(resource.license).to be == license
-    end
-
-    it "should accept the names of licenses" do
-      resource = subject.licensed_under('GPL-2').first
-
-      expect(resource.license).to be == license
-    end
-
-    after { subject.destroy }
-  end
-end

data/spec/model/has_name_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-require 'model/models/named_model'
-
-require 'ronin/model/has_name'
-
-describe Model::HasName do
-  let(:model) { NamedModel }
-
-  describe ".included" do
-    subject { model }
-
-    it "should include Ronin::Model" do
-      expect(subject.ancestors).to include(Model)
-    end
-
-    it "should define a name property" do
-      expect(subject.properties).to be_named(:name)
-    end
-  end
-
-  describe "validations" do
-    subject { model }
-
-    it "should require a name" do
-      resource = subject.new
-      expect(resource).not_to be_valid
-
-      resource.name = 'foo'
-      expect(resource).to be_valid
-    end
-  end
-
-  describe ".named" do
-    subject { model }
-
-    let(:name1) { 'foo1' }
-    let(:name2) { 'foo2' }
-
-    before do
-      subject.create!(:name => name1)
-      subject.create!(:name => name2)
-    end
-
-    it "should be able to find resources with similar names" do
-      resources = subject.named('foo')
-
-      expect(resources.length).to eq(2)
-      expect(resources[0].name).to be == name1
-      expect(resources[1].name).to be == name2
-    end
-
-    after { subject.destroy }
-  end
-end

data/spec/model/has_title_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-require 'model/models/titled_model'
-
-require 'ronin/model/has_title'
-
-describe Model::HasTitle do
-  let(:model) { TitledModel }
-
-  describe ".included" do
-    subject { model }
-
-    it "should include Ronin::Model" do
-      expect(subject.ancestors).to include(Model)
-    end
-
-    it "should define a title property" do
-      expect(subject.properties).to be_named(:title)
-    end
-  end
-
-  describe ".titled" do
-    subject { model }
-
-    let(:title1) { 'Foo one' }
-    let(:title2) { 'Foo bar two' }
-
-    before do
-      subject.create!(:title => title1)
-      subject.create!(:title => title2)
-    end
-
-    it "should be able to find resources with similar titles" do
-      resources = subject.titled('Foo')
-
-      expect(resources.length).to eq(2)
-      expect(resources[0].title).to be == title1
-      expect(resources[1].title).to be == title2
-    end
-
-    after { subject.destroy }
-  end
-end

data/spec/model/has_version_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-require 'model/models/versioned_model'
-
-require 'ronin/model/has_version'
-
-describe Model::HasVersion do
-  let(:model) { VersionedModel }
-
-  describe ".included" do
-    subject { model }
-
-    it "should include Ronin::Model" do
-      expect(subject.ancestors).to include(Model)
-    end
-
-    it "should define a version property" do
-      expect(subject.properties).to be_named(:version)
-    end
-
-    it "should default the version property to '0.1'" do
-      resource = subject.new
-
-      expect(resource.version).to eq('0.1')
-    end
-  end
-
-  describe ".revision" do
-    subject { model }
-
-    before do
-      subject.create(
-        :version => '1.1',
-        :content => 'one'
-      )
-
-      subject.create(
-        :version => '1.1',
-        :content => 'two'
-      )
-
-      subject.create(
-        :version => '1.2',
-        :content => 'three'
-      )
-    end
-
-    it "should allow querying specific revisions" do
-      resources = subject.revision('1.1')
-
-      expect(resources.length).to eq(2)
-      expect(resources[0].version).to eq('1.1')
-      expect(resources[0].content).to eq('one')
-
-      expect(resources[1].version).to eq('1.1')
-      expect(resources[1].content).to eq('two')
-    end
-
-    after { subject.destroy }
-  end
-
-  describe ".latest" do
-    subject { model }
-
-    before do
-      subject.create(
-        :version => '1.0',
-        :content => 'foo'
-      )
-
-      subject.create(
-        :version => '1.5',
-        :content => 'foo'
-      )
-
-      subject.create(
-        :version => '1.1',
-        :content => 'foo'
-      )
-    end
-
-    it "should allow querying the latest revision" do
-      resource = subject.all(:content => 'foo').latest
-
-      expect(resource.version).to eq('1.5')
-    end
-  end
-end

data/spec/model/model_spec.rb

@@ -1,98 +0,0 @@
-require 'spec_helper'
-require 'model/models/base_model'
-require 'model/models/inherited_model'
-
-require 'ronin/model/model'
-
-describe Model do
-  let(:base_model) { BaseModel }
-  let(:inherited_model) { InheritedModel }
-
-  describe ".included" do
-    subject { base_model }
-
-    it "should have a default repository name" do
-      expect(subject.default_repository_name).to eq(:default)
-    end
-  end
-
-  describe ".new" do
-    subject { base_model }
-
-    it "should allow creating new instances of the model" do
-      resource = subject.new(:name => 'joe')
-
-      expect(resource.name).to eq('joe')
-    end
-
-    context "when the model defines an initialize method" do
-      subject { inherited_model }
-
-      it "should call initialize when creating new instances of the model" do
-        resource = subject.new(:name => 'joe')
-
-        expect(resource.name).to eq('joe')
-        expect(resource.var).to eq(2)
-      end
-    end
-  end
-
-  describe ".create!" do
-    subject { inherited_model }
-
-    it "should call initialize when creating a new resource" do
-      resource = subject.create!(:name => 'jim')
-
-      expect(resource.name).to eq('jim')
-      expect(resource.var).to eq(2)
-
-      resource.destroy
-    end
-  end
-
-  describe ".first" do
-    subject { inherited_model }
-
-    before { subject.create!(:name => 'bob') }
-
-    it "should call initialize when loading from the database" do
-      resource = subject.first(:name => 'bob')
-
-      expect(resource.name).to eq('bob')
-      expect(resource.var).to eq(2)
-    end
-
-    after { subject.destroy }
-  end
-
-  describe "#humanize_attributes" do
-    let(:model) { base_model }
-
-    subject { model.new(:name => 'joe', :age => 21) }
-
-    it "should humanize the attributes of a model" do
-      expect(subject.humanize_attributes).to be == {
-        'Name' => 'joe',
-        'Age' => '21'
-      }
-    end
-
-    it "should exclude certain attributes to humanize" do
-      expect(subject.humanize_attributes(:exclude => [:name])).to be == {
-        'Age' => '21'
-      }
-    end
-
-    it "should filter out nil values" do
-      subject.age = nil
-
-      expect(subject.humanize_attributes).to be == {'Name' => 'joe'}
-    end
-
-    it "should filter out empty values" do
-      subject.name = ''
-
-      expect(subject.humanize_attributes).to be == {'Age' => '21'}
-    end
-  end
-end

data/spec/model/models/authored_model.rb

@@ -1,11 +0,0 @@
-require 'ronin/model/has_authors'
-
-class AuthoredModel
-
-  include Ronin::Model::HasAuthors
-
-  property :id, Serial
-
-  property :content, String
-
-end