dkimverify 0.0.2 → 0.0.3

data/dkim-query/spec/key_spec.rb

@@ -1,117 +0,0 @@
-require 'spec_helper'
-require 'dkim/query/key'
-
-describe Key do
-  let(:k) { :rsa }
-  let(:p) { "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB" }
-  let(:t) { :s }
-  let(:n) { "A 1024 bit key;" }
-
-  subject do
-    described_class.new(
-      k: k,
-      p: p,
-      t: t,
-      n: n
-    )
-  end
-
-  describe "#initialize" do
-    it "should set @k" do
-      expect(subject.k).to be k
-    end
-
-    it "should set @p" do
-      expect(subject.p).to be p
-    end
-
-    it "should set @t" do
-      expect(subject.t).to be t
-    end
-
-    it "should set @n" do
-      expect(subject.n).to be n
-    end
-  end
-
-  let(:record) { %{k=#{k};  p=#{p}; t=#{t}; n=#{n}} }
-  let(:invalid_record) { "v=spf1" }
-
-  describe ".parse!" do
-    context "when parsing a valid DKIM Key record" do
-      subject { described_class.parse!(record) }
-
-      it "should return a Key" do
-        expect(subject).to be_kind_of(described_class)
-      end
-
-      it "should parse k" do
-        expect(subject.k).to be k
-      end
-
-      it "should parse p" do
-        expect(subject.p).to be == p
-      end
-
-      it "should parse t" do
-        expect(subject.t).to be t
-      end
-
-      it "should parse n" do
-        expect(subject.n).to be == n
-      end
-    end
-
-    context "when parsing an invalid DKIM Key record" do
-      it "should raise an InvalidKey exception" do
-        expect {
-          described_class.parse!(invalid_record)
-        }.to raise_error(InvalidKey)
-      end
-    end
-  end
-
-  describe ".parse" do
-    context "when parsing a valid DKIM Key record" do
-      subject { described_class.parse(record) }
-
-      it "should return a Key" do
-        expect(subject).to be_kind_of(described_class)
-      end
-    end
-
-    context "when parsing an invalid DKIM Key record" do
-      subject { described_class.parse(invalid_record) }
-
-      it "should return a MalformedKey" do
-        expect(subject).to be_kind_of(MalformedKey)
-      end
-    end
-  end
-
-  describe "#to_hash" do
-    subject { super().to_hash }
-
-    it "should include :k" do
-      expect(subject[:k]).to be == k
-    end
-
-    it "should include :p" do
-      expect(subject[:p]).to be == p
-    end
-
-
-    it "should include :t" do
-      expect(subject[:t]).to be == t
-    end
-    it "should include :n" do
-      expect(subject[:n]).to be == n
-    end
-  end
-
-  describe "#to_s" do
-    it "should return a semicolon deliminited string" do
-      expect(subject.to_s).to be == "k=#{k}; p=#{p}; t=#{t}; n=#{n}"
-    end
-  end
-end

data/dkim-query/spec/malformed_key.rb

@@ -1,15 +0,0 @@
-require 'spec_helper'
-require 'dkim/query/malformed_key'
-
-describe MalformedKey do
-  describe "#to_s" do
-    let(:value) { "foo bar" }
-    let(:cause) { double(:parslet_error) }
-
-    subject { described_class.new(value,cause) }
-
-    it "should return the value" do
-      expect(subject.to_s).to be == value
-    end
-  end
-end

data/dkim-query/spec/parser_spec.rb

@@ -1,300 +0,0 @@
-require 'spec_helper'
-require 'dkim/query/parser'
-
-describe Parser do
-  describe ".parse" do
-    subject { described_class }
-
-    let(:dkim) do
-      %{k=rsa;  p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB; n=A 1024 bit key;}
-    end
-
-    it "should parse a DKIM record into a Hash" do
-      expect(subject.parse(dkim)).to be == {
-        k: :rsa,
-        p: %{MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB},
-        n: "A 1024 bit key;"
-      }
-    end
-  end
-
-  describe "tags" do
-    describe "v" do
-      subject { super().key_v_tag }
-
-      it "should parse v=DKIM1" do
-        expect(subject.parse('v=DKIM1')).to be == {
-          name: 'v',
-          value: {symbol: 'DKIM1'}
-        }
-      end
-    end
-
-    describe "g" do
-      subject { super().key_g_tag }
-    end
-
-    describe "h" do
-      subject { super().key_h_tag }
-
-      it "should parse h=sha1" do
-        expect(subject.parse('h=sha1')).to be == {
-          name: 'h',
-          value: {symbol: 'sha1'}
-        }
-      end
-
-      it "should parse h=sha256" do
-        expect(subject.parse('h=sha256')).to be == {
-          name: 'h',
-          value: {symbol: 'sha256'}
-        }
-      end
-
-      it "should parse h=sha1:sha256" do
-        expect(subject.parse('h=sha1:sha256')).to be == {
-          name: 'h',
-          value: [
-            {symbol: 'sha1'},
-            {symbol: 'sha256'}
-          ]
-        }
-      end
-
-      it "should parse h=abc-123-xyz" do
-        expect(subject.parse('h=abc-123-xyz')).to be == {
-          name: 'h',
-          value: {string: 'abc-123-xyz'}
-        }
-      end
-    end
-
-    describe "k" do
-      subject { super().key_k_tag }
-
-      it "should parse k=rsa" do
-        expect(subject.parse('k=rsa')).to be == {
-          name: 'k',
-          value: {symbol: 'rsa'}
-        }
-      end
-
-      it "should parse k=abc-123-xyz" do
-        expect(subject.parse('k=abc-123-xyz')).to be == {
-          name: 'k',
-          value: {string: 'abc-123-xyz'}
-        }
-      end
-    end
-
-    describe "n" do
-      subject { super().key_n_tag }
-
-      let(:notes) { %{A 1024 bit key} }
-
-      it "should parse n=..." do
-        expect(subject.parse("n=#{notes}")).to be == {
-          name: 'n',
-          value: {string: notes}
-        }
-      end
-    end
-
-    describe "p" do
-      subject { super().key_p_tag }
-
-      let(:base64) { %{MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB} }
-
-      it "should parse p=..." do
-        expect(subject.parse("p=#{base64}")).to be == {
-          name: 'p',
-          value: {asn1: base64}
-        }
-      end
-    end
-
-    describe "s" do
-      subject { super().key_s_tag }
-
-      it "should parse s=email" do
-        expect(subject.parse('s=email')).to be == {
-          name: 's',
-          value: {symbol: 'email'}
-        }
-      end
-
-      it "should parse s=*" do
-        expect(subject.parse('s=*')).to be == {
-          name: 's',
-          value: {symbol: '*'}
-        }
-      end
-
-      it "should parse s=email:*" do
-        expect(subject.parse('s=email:*')).to be == {
-          name: 's',
-          value: [{symbol: 'email'}, {symbol: '*'}]
-        }
-      end
-
-      it "should parse s=abc-123-xyz" do
-        expect(subject.parse('s=abc-123-xyz')).to be == {
-          name: 's',
-          value: {string: 'abc-123-xyz'}
-        }
-      end
-    end
-
-    describe "t" do
-      subject { super().key_t_tag }
-
-      it "should parse t=y" do
-        expect(subject.parse('t=y')).to be == {
-          name: 't',
-          value: {symbol: 'y'}
-        }
-      end
-
-      it "should parse t=s" do
-        expect(subject.parse('t=s')).to be == {
-          name: 't',
-          value: {symbol: 's'}
-        }
-      end
-
-      it "should parse t=abc-123-xyz" do
-        expect(subject.parse('t=abc-123-xyz')).to be == {
-          name: 't',
-          value: {string: 'abc-123-xyz'}
-        }
-      end
-    end
-  end
-
-  describe "rules" do
-    describe "dkim_quoted_printable" do
-    end
-
-    describe "dkim_safe_char" do
-    end
-
-    describe "hyphenated_word" do
-      subject { super().hyphenated_word }
-
-      it "should parse abc" do
-        expect(subject.parse('abc')).to be == 'abc'
-      end
-
-      it "should parse abc123" do
-        expect(subject.parse('abc123')).to be == 'abc123'
-      end
-
-      it "should parse a-b-c" do
-        expect(subject.parse('a-b-c')).to be == 'a-b-c'
-      end
-
-      it "should parse a---b---c" do
-        expect(subject.parse('a---b---c')).to be == 'a---b---c'
-      end
-
-      it "should not parse -a" do
-        expect { subject.parse('-a') }.to raise_error(Parslet::ParseFailed)
-      end
-
-      it "should not parse a-" do
-        expect { subject.parse('a-') }.to raise_error(Parslet::ParseFailed)
-      end
-
-      it "should not parse -" do
-        expect { subject.parse('-') }.to raise_error(Parslet::ParseFailed)
-      end
-    end
-
-    describe "base64string" do
-    end
-
-    describe "qp_section" do
-      subject { super().qp_section }
-
-      it "should parse \"A\"" do
-        expect(subject.parse('A')).to be == 'A'
-      end
-
-      it "should parse \"AAA\"" do
-        expect(subject.parse('AAA')).to be == 'AAA'
-      end
-
-      it "should parse \" A\"" do
-        expect(subject.parse(' A')).to be == ' A'
-      end
-
-      it "should parse \"A B\"" do
-        expect(subject.parse('A B')).to be == 'A B'
-      end
-
-      it "should not parse \" \"" do
-        expect {
-          subject.parse(' ')
-        }.to raise_error(Parslet::ParseFailed)
-      end
-
-      it "should not parse \"A \"" do
-        expect {
-          subject.parse('A ')
-        }.to raise_error(Parslet::ParseFailed)
-      end
-    end
-
-    describe "hex_octet" do
-    end
-  end
-
-  describe Parser::Transform do
-    context "when given {symbol: ...}" do
-      let(:string) { 'foo' }
-
-      it "should convert the string into a Symbol" do
-        expect(subject.apply(symbol: string)).to be == string.to_sym
-      end
-    end
-
-    context "when given {tag: {name: ..., value: ...}}" do
-      let(:name)  { 'foo' }
-      let(:value) { 'bar' }
-
-      it "should convert the string into Hash" do
-        expect(subject.apply(
-          {tag: {name: name, value: value}}
-        )).to be == {name.to_sym => value}
-      end
-    end
-
-    context "when given {tag: {name: ..., value: [...]}}" do
-      let(:name)  { 'foo' }
-      let(:value) { ['a', 'b'] }
-
-      it "should convert the string into Hash" do
-        expect(subject.apply(
-          {tag: {name: name, value: value}}
-        )).to be == {name.to_sym => value}
-      end
-    end
-
-    context "when {tag_list: {...}}" do
-      let(:hash) { {foo: 'bar'} }
-
-      it "should return the single Hash" do
-        expect(subject.apply({tag_list: hash})).to be == hash
-      end
-    end
-
-    context "when {tag_list: [{...}, ...]}" do
-      let(:hashes) { [{foo: 'bar'}, {baz: 'quix'}] }
-      let(:hash)   { {foo: 'bar', baz: 'quix'} }
-
-      it "should merge the Hashes together" do
-        expect(subject.apply({tag_list: hashes})).to be == hash
-      end
-    end
-  end
-end

data/dkim-query/spec/query_spec.rb

@@ -1,68 +0,0 @@
-require 'spec_helper'
-require 'dkim/query/query'
-
-describe DKIM::Query do
-  subject { described_class }
-
-  let(:domain) { 'yahoo.com' }
-
-  describe ".host_without_tld" do
-    let(:tld) { ".com" }
-
-    it "should strip the last component of the domain" do
-      expect(subject.host_without_tld(domain)).to be == domain.chomp(tld)
-    end
-
-    context "when given a host with no tld" do
-      let(:domain) { 'test' }
-
-      it "should return the full host" do
-        expect(subject.host_without_tld(domain)).to be == domain
-      end
-    end
-  end
-
-  describe ".selectors_for" do
-    subject { described_class.selectors_for(domain) }
-
-    described_class::SELECTORS.each do |selector|
-      it "should include '#{selector}'" do
-        expect(subject).to include(selector)
-      end
-    end
-
-    it "should include the domain without the TLD" do
-      expect(subject).to include('yahoo')
-    end
-  end
-
-  describe ".query" do
-    it "should return all found DKIM keys" do
-      expect(subject.query(domain)).to be == {
-        's1024' => 'k=rsa;  p=MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDrEee0Ri4Juz+QfiWYui/E9UGSXau/2P8LjnTD8V4Unn+2FAZVGE3kL23bzeoULYv4PeleB3gfmJiDJOKU3Ns5L4KJAUUHjFwDebt0NP+sBK0VKeTATL2Yr/S3bT/xhy+1xtj4RkdV7fVxTn56Lb4udUnwuxK4V5b5PdOKj/+XcwIDAQAB; n=A 1024 bit key;'
-      }
-    end
-
-    context "with custom selectors" do
-      let(:selectors) { ['google', 's1024'] }
-
-      it "should query those selectors only" do
-        expect(subject.query(domain, selectors: selectors)).to have_key('s1024')
-      end
-    end
-
-    context "with no selectors" do
-      it "should not find any keys" do
-        expect(subject.query(domain, selectors: [])).to be_empty
-      end
-    end
-
-    context "when given an invalid domain" do
-      let(:domain) { 'foo.bar.com' }
-
-      it "should return {}" do
-        expect(subject.query(domain)).to be == {}
-      end
-    end
-  end
-end

data/dkim-query/spec/spec_helper.rb

@@ -1,13 +0,0 @@
-if ENV['CODECLIMATE_REPO_TOKEN']
-  require "codeclimate-test-reporter"
-  CodeClimate::TestReporter.start
-end
-
-require 'rspec'
-require 'dkim/query'
-
-include DKIM::Query
-
-RSpec.configure do |specs|
-  specs
-end

data/dkim-query/tasks/alexa.rb

@@ -1,43 +0,0 @@
-##
-# Adapted from gist: https://gist.github.com/zerothabhishek/3015666
-# Orginal author: zerothabhishek
-##
-
-require 'nokogiri'
-require 'open-uri'
-require 'resolv'
-require 'csv'
-
-namespace :alexa do
-  desc 'Scrapes the Alexa Top 500 and updates spec/data/alexa.csv'
-  task :scrape do
-    resolver = Resolv::DNS.new
-
-    CSV.open("spec/data/alexa.csv","w") do |csv|
-      (0..19).each do |i|
-        url = "http://www.alexa.com/topsites/global;#{i} "
-        doc = Nokogiri::HTML(open(url))
-
-        doc.css(".site-listing").each do |li|
-          begin
-            site_name = li.css(".desc-container .desc-paragraph a")[0].content
-            site_rank = li.css(".count")[0].content
-
-            puts "Resolving #{site_name} ..."
-            dmarc = begin
-                      resolver.getresource(
-                        "_dmarc.#{site_name.downcase}",
-                        Resolv::DNS::Resource::IN::TXT
-                      ).strings.join
-                    rescue Resolv::ResolvError
-                    end
-
-            csv << [site_rank, site_name, dmarc]
-          rescue => exception
-            warn exception.message
-          end
-        end
-      end
-    end
-  end
-end