gman 6.0.1 → 7.0.4

data/spec/gman/domains_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Gman domains' do
+  let(:resolve_domains?) { ENV['GMAN_RESOLVE_DOMAINS'] == 'true' }
+  let(:importer) { Gman::Importer.new({}) }
+  let(:options) { { skip_dupe: true, skip_resolve: !resolve_domains? } }
+
+  Gman.list.to_h.each do |group, domains|
+    next if ['non-us gov', 'non-us mil', 'US Federal'].include?(group)
+
+    context "the #{group} group" do
+      it 'only contains valid domains' do
+        invalid_domains = []
+
+        Parallel.each(domains, in_threads: 4) do |domain|
+          next if importer.valid_domain?(domain, options)
+
+          invalid_domains.push domain
+        end
+
+        expect(invalid_domains).to be_empty
+      end
+    end
+  end
+end

data/spec/gman/identifier_spec.rb

@@ -0,0 +1,218 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Gman identifier' do
+  subject { Gman.new(domain) }
+
+  let(:domain) { '' }
+
+  it 'parses the dotgov list' do
+    expect(Gman.dotgov_list).to be_a(CSV::Table)
+    expect(Gman.dotgov_list.first).to have_key('Domain Name')
+  end
+
+  context 'locality domains' do
+    context 'a state domain' do
+      let(:domain) { 'state.ak.us' }
+
+      it "knows it's a state" do
+        expect(subject).to be_a_state
+        expect(subject.type).to be(:state)
+      end
+
+      it 'knows the state' do
+        expect(subject.state).to eql('AK')
+      end
+
+      it "knows it's not a dotgov" do
+        expect(subject).not_to be_a_dotgov
+      end
+
+      it "know's it's not a city" do
+        expect(subject).not_to be_a_city
+      end
+
+      it "know's it's not a county" do
+        expect(subject).not_to be_a_county
+      end
+    end
+
+    context 'a city domain' do
+      let(:domain) { 'ci.champaign.il.us' }
+
+      it "knows it's a city" do
+        expect(subject).to be_a_city
+        expect(subject.type).to be(:city)
+      end
+
+      it 'knows the state' do
+        expect(subject.state).to eql('IL')
+      end
+
+      it "knows it's not a dotgov" do
+        expect(subject).not_to be_a_dotgov
+      end
+
+      it "know's it's not a state" do
+        expect(subject).not_to be_a_state
+      end
+
+      it "know's it's not a county" do
+        expect(subject).not_to be_a_county
+      end
+    end
+
+    context 'dotgovs' do
+      context 'A federal dotgov' do
+        let(:domain) { 'whitehouse.gov' }
+
+        it "knows it's federal" do
+          expect(subject).to be_federal
+          expect(subject.type).to be(:federal)
+        end
+
+        it "knows it's a dotgov" do
+          expect(subject).to be_a_dotgov
+        end
+
+        it "knows it's not a city" do
+          expect(subject).not_to be_a_city
+        end
+
+        it "knows it's not a state" do
+          expect(subject).not_to be_a_state
+        end
+
+        it "knows it's not a county" do
+          expect(subject).not_to be_a_county
+        end
+
+        it 'knows the state' do
+          expect(subject.state).to eql('DC')
+        end
+
+        it 'knows the city' do
+          expect(subject.city).to eql('Washington')
+        end
+
+        it 'knows the agency' do
+          expect(subject.agency).to eql('Executive Office of the President')
+        end
+
+        it 'knows the organization' do
+          expect(subject.organization).to eql('White House')
+        end
+      end
+
+      context 'a state .gov' do
+        let(:domain) { 'illinois.gov' }
+
+        it "knows it's a state" do
+          expect(subject).to be_a_state
+          expect(subject.type).to be(:state)
+        end
+
+        it "knows it's a dotgov" do
+          expect(subject).to be_a_dotgov
+        end
+
+        it "knows it's not a city" do
+          expect(subject).not_to be_a_city
+        end
+
+        it "knows it's not federal" do
+          expect(subject).not_to be_federal
+        end
+
+        it "knows it's not a county" do
+          expect(subject).not_to be_a_county
+        end
+
+        it 'knows the state' do
+          expect(subject.state).to eql('IL')
+        end
+
+        it 'knows the city' do
+          expect(subject.city).to eql('Springfield')
+        end
+      end
+
+      context 'a county .gov' do
+        let(:domain) { 'ALLEGHENYCOUNTYPA.GOV' }
+
+        it "knows it's a county" do
+          expect(subject).to be_a_county
+          expect(subject.type).to be(:county)
+        end
+
+        it "knows it's a dotgov" do
+          expect(subject).to be_a_dotgov
+        end
+
+        it "knows it's not a city" do
+          expect(subject).not_to be_a_city
+        end
+
+        it "knows it's not federal" do
+          expect(subject).not_to be_federal
+        end
+
+        it "knows it's not a state" do
+          expect(subject).not_to be_a_state
+        end
+
+        it 'knows the state' do
+          expect(subject.state).to eql('PA')
+        end
+
+        it 'knows the city' do
+          expect(subject.city).to eql('Pittsburgh')
+        end
+      end
+
+      context 'a city .gov' do
+        let(:domain) { 'ABERDEENMD.GOV' }
+
+        it "knows it's a city" do
+          expect(subject).to be_a_city
+          expect(subject.type).to be(:city)
+        end
+
+        it 'knows the city' do
+          expect(subject.city).to eql('Aberdeen')
+        end
+
+        it 'knows the state' do
+          expect(subject.state).to eql('MD')
+        end
+
+        it "knows it's a dotgov" do
+          expect(subject).to be_a_dotgov
+        end
+
+        it "know's it's not a state" do
+          expect(subject).not_to be_a_state
+        end
+
+        it "know's it's not a county" do
+          expect(subject).not_to be_a_county
+        end
+      end
+    end
+  end
+
+  context "determining a domain's type" do
+    {
+      unknown: 'cityofperu.org',
+      "Canada municipal": 'acme.ca',
+      "Canada federal": 'canada.ca'
+    }.each do |expected, domain|
+      context "Given the #{domain} domain" do
+        let(:domain) { domain }
+
+        it "know's the domain's type" do
+          expect(subject.type).to eql(expected)
+        end
+      end
+    end
+  end
+end

data/spec/gman/importer_spec.rb

@@ -0,0 +1,236 @@
+# frozen_string_literal: true
+
+RSpec.describe Gman::Importer do
+  subject { described_class.new(domains) }
+
+  let(:domains) { { 'test' => ['example.com'] } }
+  let(:stdout) { StringIO.new }
+  let(:logger) { Logger.new(@stdout) }
+  let(:domain_list) { subject.domain_list }
+
+  before do
+    subject.instance_variable_set '@logger', logger
+  end
+
+  it 'inits the domain list' do
+    expect(domain_list).to be_a(Gman::DomainList)
+    expect(domain_list.count).to be(1)
+    expect(domain_list.domains.first).to eql('example.com')
+  end
+
+  it 'inits the logger' do
+    expect(subject.logger).to be_a(Logger)
+  end
+
+  it 'returns the current domain list' do
+    expect(subject.current).to be_a(Gman::DomainList)
+  end
+
+  it 'returns the resolver' do
+    expect(subject.resolver).to be_a(Resolv::DNS)
+  end
+
+  context 'domain rejection' do
+    it 'returns false' do
+      expect(subject.reject('example.com', 'reasons')).to be(false)
+    end
+
+    it 'returns the reason why asked' do
+      with_env 'RECONCILING', 'true' do
+        expect(subject.reject('example.com', 'reasons')).to eql('reasons')
+      end
+    end
+  end
+
+  context 'manipulating the domain list' do
+    context 'normalizing domains' do
+      let(:domains) { { 'test' => ['www.EXAMPLE.com/'] } }
+
+      before { subject.send :normalize_domains! }
+
+      it 'normalizes the domains' do
+        expect(domain_list.domains.first).to eql('example.com')
+      end
+    end
+
+    context 'removing invalid domains' do
+      let(:domains) { { 'test' => ['foo.github.io', 'example.com'] } }
+
+      before { subject.send :ensure_validity! }
+
+      it 'removes invalid domains' do
+        expect(domain_list.count).to be(1)
+      end
+    end
+  end
+
+  context 'with the current list stubbed' do
+    let(:stubbed_list) { Gman::DomainList.new(path: stubbed_list_path) }
+    let(:stubbed_file_contents) { File.read(stubbed_list_path) }
+
+    before { subject.instance_variable_set '@current', stubbed_list }
+
+    context 'writing' do
+      before { @current = subject.current.to_s }
+
+      before { subject.send :add_to_current }
+
+      after  { File.write(stubbed_list_path, @current) }
+
+      context 'adding domains' do
+        let(:domains) do
+          { 'test' => ['example.com'], 'test2' => ['github.com'] }
+        end
+
+        it 'adds the domains' do
+          expected = "// test\nexample.com\n\n// test2\ngithub.com"
+          expect(stubbed_file_contents).to match(expected)
+        end
+      end
+
+      context 'importing' do
+        let(:domains) do
+          {
+            'test' => ['www.example.com', 'foo.github.io'],
+            'test2' => ['github.com', 'www.github.com', 'whitehouse.gov']
+          }
+        end
+
+        before { subject.import(skip_resolve: true) }
+
+        it 'imports' do
+          expected = "// test\nexample.com\nfoo.github.io"
+          expect(stubbed_file_contents).to match(expected)
+
+          expected = "// test2\ngithub.com\nwhitehouse.gov"
+          expect(stubbed_file_contents).to match(expected)
+        end
+      end
+    end
+  end
+
+  context 'domain validation' do
+    let(:domain) { '' }
+    let(:valid?) { subject.send(:ensure_valid, domain) }
+
+    context 'a valid domain' do
+      let(:domain) { 'whitehouse.gov' }
+
+      it 'is valid' do
+        expect(valid?).to be(true)
+      end
+    end
+
+    {
+      empty: '',
+      blacklisted: 'egovlink.com',
+      invalid: 'foo.invalid',
+      academic: 'harvard.edu',
+      "rejex'd": 'foo.github.io'
+    }.each_key do |type|
+      context "a #{type} domain" do
+        it 'is invalid' do
+          expect(valid?).to be(false)
+        end
+      end
+    end
+  end
+
+  context 'duplicate domains' do
+    let(:dupe?) { subject.send(:dupe?, domain) }
+    let(:ensure_not_dupe) { subject.send(:ensure_not_dupe, domain) }
+
+    context 'a unique domain' do
+      let(:domain) { 'gman.com' }
+
+      it 'is not a dupe' do
+        expect(dupe?).to be_falsy
+        expect(ensure_not_dupe).to be_truthy
+      end
+    end
+
+    context 'a duplicate domain' do
+      let(:domain) { 'gov' }
+
+      it "knows it's a dupe" do
+        expect(dupe?).to be_truthy
+        expect(ensure_not_dupe).to be_falsy
+      end
+
+      context 'a subdomain' do
+        let(:domain) { 'whitehouse.gov' }
+
+        it "know when a domain's a subdomain of an existing domain" do
+          expect(dupe?).to be_truthy
+          expect(ensure_not_dupe).to be_falsy
+        end
+      end
+    end
+  end
+
+  context 'domain resolution' do
+    let(:resolves?) { subject.domain_resolves?(domain) }
+    let(:ensure_resolves) { subject.send(:ensure_resolves, domain) }
+
+    context 'a valid domain' do
+      let(:domain) { 'github.com' }
+
+      it 'resolves' do
+        expect(resolves?).to be_truthy
+        expect(ensure_resolves).to be_truthy
+      end
+    end
+
+    context 'an invalid domain' do
+      let(:domain) { 'foo.invalid' }
+
+      it "doesn't resolve" do
+        expect(resolves?).to be_falsy
+        expect(ensure_resolves).to be_falsy
+      end
+    end
+  end
+
+  context 'regex checks' do
+    let(:ensure_regex) { subject.send(:ensure_regex, domain) }
+
+    context 'valid domains' do
+      let(:domain) { 'example.com' }
+
+      it 'passes' do
+        expect(ensure_regex).to be_truthy
+      end
+    end
+
+    [
+      'home.example.com', 'site.example.com', 'user.example.com',
+      'foo.weebly.com', 'foo.wordpress.com', 'foo.govoffice.com',
+      'foo.govoffice1.com', 'foo.homestead.com', 'foo.wix.com',
+      'foo.blogspot.com', 'foo.tripod.com', 'foo.squarespace.com',
+      'foo.github.io', 'ci.champaign.il.us'
+    ].each do |domain|
+      context "a #{domain} domain" do
+        let(:domain) { domain }
+
+        it 'rejects the domain' do
+          expect(ensure_regex).to be_falsy
+        end
+      end
+    end
+  end
+
+  context 'normalizing domains' do
+    let(:normalized_domain) { subject.normalize_domain(domain) }
+
+    [
+      'http://example.com', 'www.example.com', 'example.com/',
+      'example.com/foo', 'example.com/foo/', 'EXAMPLE.com'
+    ].each do |domain|
+      let(:domain) { domain }
+
+      it 'normalizes the domain' do
+        expect(normalized_domain).to eql('example.com')
+      end
+    end
+  end
+end