ronin-core 0.1.0.beta1 → 0.1.1

data/spec/metadata/authors/author_spec.rb

@@ -1,335 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/metadata/authors/author'
-
-describe Ronin::Core::Metadata::Authors::Author do
-  let(:name)    { 'John Smith'               }
-  let(:email)   { 'john.smith@example.com'   }
-  let(:pgp)     { '0x123456789'              }
-  let(:website) { 'https://jsmith.name'      }
-  let(:blog)    { 'https://blog.jsmith.name' }
-  let(:github)  { 'jsmith_github'            }
-  let(:gitlab)  { 'jsmith_gitlab'            }
-  let(:twitter) { 'jsmith_twitter'           }
-  let(:discord) { 'jsmith_discord'           }
-
-  describe "#initialize" do
-    subject { described_class.new(name) }
-
-    it "must set #name" do
-      expect(subject.name).to eq(name)
-    end
-
-    context "when given the email: keyword argument" do
-      subject { described_class.new(name, email: email) }
-
-      it "must set #email" do
-        expect(subject.email).to eq(email)
-      end
-    end
-
-    context "when given the pgp: keyword argument" do
-      subject { described_class.new(name, pgp: pgp) }
-
-      it "must set #pgp" do
-        expect(subject.pgp).to eq(pgp)
-      end
-    end
-
-    context "when given the website: keyword argument" do
-      subject { described_class.new(name, website: website) }
-
-      it "must set #website" do
-        expect(subject.website).to eq(website)
-      end
-    end
-
-    context "when given the blog: keyword argument" do
-      subject { described_class.new(name, blog: blog) }
-
-      it "must set #blog" do
-        expect(subject.blog).to eq(blog)
-      end
-    end
-
-    context "when given the github: keyword argument" do
-      subject { described_class.new(name, github: github) }
-
-      it "must set #github" do
-        expect(subject.github).to eq(github)
-      end
-    end
-
-    context "when given the gitlab: keyword argument" do
-      subject { described_class.new(name, gitlab: gitlab) }
-
-      it "must set #gitlab" do
-        expect(subject.gitlab).to eq(gitlab)
-      end
-    end
-
-    context "when given the twitter: keyword argument" do
-      subject { described_class.new(name, twitter: twitter) }
-
-      it "must set #twitter" do
-        expect(subject.twitter).to eq(twitter)
-      end
-    end
-
-    context "when given the discord: keyword argument" do
-      subject { described_class.new(name, discord: discord) }
-
-      it "must set #discord" do
-        expect(subject.discord).to eq(discord)
-      end
-    end
-  end
-
-  subject do
-    described_class.new(name, email:   email,
-                              pgp:     pgp,
-                              github:  github,
-                              gitlab:  gitlab,
-                              twitter: twitter,
-                              discord: discord)
-  end
-
-  describe "#email?" do
-    context "when #email is set" do
-      subject { described_class.new(name, email: email) }
-
-      it "must return true" do
-        expect(subject.email?).to be(true)
-      end
-    end
-
-    context "when #email is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.email?).to be(false)
-      end
-    end
-  end
-
-  describe "#pgp?" do
-    context "when #pgp is set" do
-      subject { described_class.new(name, pgp: pgp) }
-
-      it "must return true" do
-        expect(subject.pgp?).to be(true)
-      end
-    end
-
-    context "when #pgp is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.pgp?).to be(false)
-      end
-    end
-  end
-
-  describe "#website?" do
-    context "when #website is set" do
-      subject { described_class.new(name, website: website) }
-
-      it "must return true" do
-        expect(subject.website?).to be(true)
-      end
-    end
-
-    context "when #website is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.website?).to be(false)
-      end
-    end
-  end
-
-  describe "#blog?" do
-    context "when #blog is set" do
-      subject { described_class.new(name, blog: blog) }
-
-      it "must return true" do
-        expect(subject.blog?).to be(true)
-      end
-    end
-
-    context "when #blog is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.blog?).to be(false)
-      end
-    end
-  end
-
-  describe "#github?" do
-    context "when #github is set" do
-      subject { described_class.new(name, github: github) }
-
-      it "must return true" do
-        expect(subject.github?).to be(true)
-      end
-    end
-
-    context "when #github is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.github?).to be(false)
-      end
-    end
-  end
-
-  describe "#gitlab?" do
-    context "when #gitlab is set" do
-      subject { described_class.new(name, gitlab: gitlab) }
-
-      it "must return true" do
-        expect(subject.gitlab?).to be(true)
-      end
-    end
-
-    context "when #gitlab is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.gitlab?).to be(false)
-      end
-    end
-  end
-
-  describe "#twitter?" do
-    context "when #twitter is set" do
-      subject { described_class.new(name, twitter: twitter) }
-
-      it "must return true" do
-        expect(subject.twitter?).to be(true)
-      end
-    end
-
-    context "when #twitter is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.twitter?).to be(false)
-      end
-    end
-  end
-
-  describe "#discord?" do
-    context "when #discord is set" do
-      subject { described_class.new(name, discord: discord) }
-
-      it "must return true" do
-        expect(subject.discord?).to be(true)
-      end
-    end
-
-    context "when #discord is not set" do
-      subject { described_class.new(name) }
-
-      it "must return false" do
-        expect(subject.discord?).to be(false)
-      end
-    end
-  end
-
-  describe "#github_url" do
-    context "when #github is set" do
-      subject { described_class.new(name, github: github) }
-
-      it "must return the 'https://github.com/...' URL" do
-        expect(subject.github_url).to eq("https://github.com/#{github}")
-      end
-
-      context "but the twitter handle starts with a '@'" do
-        subject { described_class.new(name, github: "@#{github}") }
-
-        it "must omit the leading '@' character" do
-          expect(subject.github_url).to eq("https://github.com/#{github}")
-        end
-      end
-    end
-
-    context "when #github is not set" do
-      subject { described_class.new(name) }
-
-      it "must return nil" do
-        expect(subject.github_url).to be(nil)
-      end
-    end
-  end
-
-  describe "#gitlab_url" do
-    context "when #gitlab is set" do
-      subject { described_class.new(name, gitlab: gitlab) }
-
-      it "must return the 'https://gitlab.com/...' URL" do
-        expect(subject.gitlab_url).to eq("https://gitlab.com/#{gitlab}")
-      end
-
-      context "but the twitter handle starts with a '@'" do
-        subject { described_class.new(name, gitlab: "@#{gitlab}") }
-
-        it "must omit the leading '@' character" do
-          expect(subject.gitlab_url).to eq("https://gitlab.com/#{gitlab}")
-        end
-      end
-    end
-
-    context "when #gitlab is not set" do
-      subject { described_class.new(name) }
-
-      it "must return nil" do
-        expect(subject.gitlab_url).to be(nil)
-      end
-    end
-  end
-
-  describe "#twitter_url" do
-    context "when #twitter is set" do
-      subject { described_class.new(name, twitter: twitter) }
-
-      it "must return the 'https://twitter.com/...' URL" do
-        expect(subject.twitter_url).to eq("https://twitter.com/#{twitter}")
-      end
-
-      context "but the twitter handle starts with a '@'" do
-        subject { described_class.new(name, twitter: "@#{twitter}") }
-
-        it "must omit the leading '@' character" do
-          expect(subject.twitter_url).to eq("https://twitter.com/#{twitter}")
-        end
-      end
-    end
-
-    context "when #twitter is not set" do
-      subject { described_class.new(name) }
-
-      it "must return nil" do
-        expect(subject.twitter_url).to be(nil)
-      end
-    end
-  end
-
-  describe "#to_s" do
-    context "when #name and #email are set" do
-      subject { described_class.new(name, email: email) }
-
-      it "must return a formatted email address with the name" do
-        expect(subject.to_s).to eq("#{name} <#{email}>")
-      end
-    end
-
-    context "when only #name is set" do
-      subject { described_class.new(name) }
-
-      it "must return #name" do
-        expect(subject.to_s).to eq(name)
-      end
-    end
-  end
-end

data/spec/metadata/authors_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/metadata/authors'
-
-describe Ronin::Core::Metadata::Authors do
-  module TestMetadataAuthor
-    class WithNoAuthors
-      include Ronin::Core::Metadata::Authors
-    end
-
-    class WithOneAuthor
-      include Ronin::Core::Metadata::Authors
-
-      author 'John Doe'
-    end
-
-    class InheritesAuthors < WithOneAuthor
-    end
-
-    class InheritesAndAddsAuthors < WithOneAuthor
-      author 'John Smith'
-    end
-
-    class WitthMultipleAuthors
-      include Ronin::Core::Metadata::Authors
-
-      author 'John Doe'
-      author 'John Smith'
-    end
-  end
-
-  describe ".authors" do
-    subject { test_class }
-
-    context "with there are no authors" do
-      let(:test_class) { TestMetadataAuthor::WithNoAuthors }
-
-      it "must default to []" do
-        expect(subject.authors).to eq([])
-      end
-    end
-
-    context "with at least one author" do
-      let(:test_class) { TestMetadataAuthor::WithOneAuthor }
-
-      it "must contain #{described_class::Author} objects" do
-        expect(subject.authors).to all(be_kind_of(described_class::Author))
-      end
-    end
-
-    context "when the super-class defines it's own authors" do
-      let(:test_class)  { TestMetadataAuthor::InheritesAuthors }
-      let(:super_class) { test_class.superclass }
-
-      it "must inherit the authors from the super-class" do
-        expect(subject.authors).to eq(super_class.authors)
-      end
-
-      context "but the sub-class defines additional authors" do
-        let(:test_class) { TestMetadataAuthor::InheritesAndAddsAuthors }
-
-        it "must combine the sub-classes authors with the super-classes" do
-          expect(subject.authors).to include(*super_class.authors)
-        end
-
-        it "must not modify the superclasses authors" do
-          expect(super_class.authors).to_not contain_exactly(*subject.authors)
-        end
-      end
-    end
-  end
-
-  describe ".author" do
-    subject { test_class }
-
-    context "when called with just a name" do
-      module TestMetadataAuthor
-        class AuthorWithOnlyName
-          include Ronin::Core::Metadata::Authors
-
-          author 'John Doe'
-        end
-      end
-
-      let(:test_class) { TestMetadataAuthor::AuthorWithOnlyName }
-      let(:author)     { subject.authors.last }
-
-      it "must initialize the #{described_class::Author} object with that name and add it to .authors" do
-        expect(author).to be_kind_of(described_class::Author)
-        expect(author.name).to eq('John Doe')
-      end
-    end
-
-    context "when additional keyword arguments are given" do
-      module TestMetadataAuthor
-        class AuthorsWithContactInfo
-          include Ronin::Core::Metadata::Authors
-
-          author 'John Smith', email:   'john.smith@example.com',
-                               pgp:     '0x123456789',
-                               website: 'https://jsmith.name',
-                               blog:    'https://jsmith.name/blog',
-                               github:  'jsmith1',
-                               gitlab:  'jsmith2',
-                               twitter: 'jsmith3',
-                               discord: 'jsmith4'
-        end
-      end
-
-      let(:test_class) { TestMetadataAuthor::AuthorsWithContactInfo }
-      let(:author)     { subject.authors.last }
-
-      it "must initialize #{described_class}::Author with those keywords and add it to .authors" do
-        expect(author).to be_kind_of(described_class::Author)
-        expect(author.name).to     eq('John Smith')
-        expect(author.email).to    eq('john.smith@example.com')
-        expect(author.pgp).to      eq('0x123456789')
-        expect(author.website).to  eq('https://jsmith.name')
-        expect(author.blog).to     eq('https://jsmith.name/blog')
-        expect(author.github).to   eq('jsmith1')
-        expect(author.gitlab).to   eq('jsmith2')
-        expect(author.twitter).to  eq('jsmith3')
-        expect(author.discord).to  eq('jsmith4')
-      end
-    end
-  end
-end

data/spec/metadata/description_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/metadata/description'
-
-describe Ronin::Core::Metadata::Description do
-  describe ".description" do
-    subject { test_class }
-
-    context "and when description is not set in the class" do
-      module TestMetadataDescription
-        class WithNoDescriptionSet
-          include Ronin::Core::Metadata::Description
-        end
-      end
-
-      let(:test_class) { TestMetadataDescription::WithNoDescriptionSet }
-
-      it "must default to nil" do
-        expect(subject.description).to be(nil)
-      end
-    end
-
-    context "and when description is set in the class" do
-      module TestMetadataDescription
-        class WithDescriptionSet
-          include Ronin::Core::Metadata::Description
-
-          description 'test'
-        end
-      end
-
-      let(:test_class) { TestMetadataDescription::WithDescriptionSet }
-
-      it "must return the set description" do
-        expect(subject.description).to eq("test")
-      end
-    end
-
-    context "but when the description was set in the superclass" do
-      module TestMetadataDescription
-        class InheritsItsDescription < WithDescriptionSet
-          include Ronin::Core::Metadata::Description
-        end
-      end
-
-      let(:test_class) { TestMetadataDescription::InheritsItsDescription }
-
-      it "must return the description set in the superclass" do
-        expect(subject.description).to eq("test")
-      end
-
-      context "but the description is overridden in the sub-class" do
-        module TestMetadataDescription
-          class OverridesItsInheritedDescription < WithDescriptionSet
-            include Ronin::Core::Metadata::Description
-
-            description "test2"
-          end
-        end
-
-        let(:test_class) do
-          TestMetadataDescription::OverridesItsInheritedDescription
-        end
-
-        it "must return the description set in the sub-class" do
-          expect(subject.description).to eq("test2")
-        end
-
-        it "must not modify the superclass'es description" do
-          expect(subject.superclass.description).to eq('test')
-        end
-      end
-    end
-  end
-end

data/spec/metadata/id_spec.rb

@@ -1,92 +0,0 @@
-require 'spec_helper'
-require 'ronin/core/metadata/id'
-
-describe Ronin::Core::Metadata::ID do
-  module TestMetadataID
-    class WithNoIDSet
-      include Ronin::Core::Metadata::ID
-    end
-
-    class WithIDSet
-      include Ronin::Core::Metadata::ID
-
-      id 'test'
-    end
-  end
-
-  describe ".id" do
-    subject { test_class }
-
-    context "and when id is not set in the class" do
-      let(:test_class) { TestMetadataID::WithNoIDSet }
-
-      it "must default to nil" do
-        expect(subject.id).to be(nil)
-      end
-    end
-
-    context "and when id is set in the class" do
-      let(:test_class) { TestMetadataID::WithIDSet }
-
-      it "must return the set id" do
-        expect(subject.id).to eq("test")
-      end
-    end
-
-    context "but when the id was set in the superclass" do
-      module TestMetadataID
-        class InheritsItsID < WithIDSet
-          include Ronin::Core::Metadata::ID
-        end
-      end
-
-      let(:test_class) { TestMetadataID::InheritsItsID }
-
-      it "must return nil" do
-        expect(subject.id).to be(nil)
-      end
-
-      context "but the id is overridden in the sub-class" do
-        module TestMetadataID
-          class OverridesItsInheritedID < WithIDSet
-            include Ronin::Core::Metadata::ID
-
-            id "test2"
-          end
-        end
-
-        let(:test_class) do
-          TestMetadataID::OverridesItsInheritedID
-        end
-
-        it "must return the id set in the sub-class" do
-          expect(subject.id).to eq("test2")
-        end
-
-        it "must not modify the superclass'es id" do
-          expect(subject.superclass.id).to eq('test')
-        end
-      end
-    end
-  end
-
-  describe "#class_id" do
-    subject { test_class.new }
-
-    context "when the class'es .id is not set" do
-      let(:test_class) { TestMetadataID::WithNoIDSet }
-
-      it "must return nil" do
-        expect(subject.class_id).to be(nil)
-      end
-    end
-
-    context "when the class'es .id is set" do
-      let(:test_class) { TestMetadataID::WithIDSet }
-
-      it "must return the .id" do
-        expect(subject.class_id).to eq(test_class.id)
-      end
-    end
-  end
-end