ronin-core 0.1.0.beta1

data/spec/metadata/authors/author_spec.rb

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

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

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

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