gman 7.0.0 → 7.0.5

data/spec/gman/bin_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Gman bin' do
+  let(:domain) { 'whitehouse.gov' }
+  let(:args) { [domain] }
+  let(:command) { 'gman' }
+  let(:bin_path) do
+    File.expand_path "../../bin/#{command}", File.dirname(__FILE__)
+  end
+  let(:response_parts) { Open3.capture2e('bundle', 'exec', bin_path, *args) }
+  let(:output) { response_parts[0] }
+  let(:status) { response_parts[1] }
+  let(:exit_code) { status.exitstatus }
+
+  context 'a valid domain' do
+    it 'parses the domain' do
+      expect(output).to match('Domain  : whitehouse.gov')
+    end
+
+    it "knows it's valid" do
+      expect(output).to match('Valid government domain')
+      expect(exit_code).to be(0)
+    end
+
+    it 'knows the type' do
+      expect(output).to match(/federal/i)
+    end
+
+    it 'knows the agency' do
+      expect(output).to match('Executive Office of the President')
+    end
+
+    it 'knows the country' do
+      expect(output).to match('United States')
+    end
+
+    it 'knows the city' do
+      expect(output).to match('Washington')
+    end
+
+    it 'knows the state' do
+      expect(output).to match('DC')
+    end
+
+    it 'colors by default' do
+      expect(output).to match(/\e\[32m/)
+    end
+
+    context 'with colorization disabled' do
+      let(:args) { [domain, '--no-color'] }
+
+      it "doesn't color" do
+        expect(output).not_to match(/\e\[32m/)
+      end
+    end
+  end
+
+  context 'with no args' do
+    let(:args) { [] }
+
+    it 'displays the help text' do
+      expect(output).to match('USAGE')
+    end
+  end
+
+  context 'an invalid domain' do
+    let(:domain) { 'foo.invalid' }
+
+    it 'knows the domain is invalid' do
+      expect(output).to match('Invalid domain')
+      expect(exit_code).to be(1)
+    end
+  end
+
+  context 'a non-government domain' do
+    let(:domain) { 'github.com' }
+
+    it "knows it's not a government domain" do
+      expect(output).to match('Not a government domain')
+      expect(exit_code).to be(1)
+    end
+  end
+
+  context 'filtering' do
+    let(:command) { 'gman_filter' }
+    let(:txt_path) do
+      File.expand_path '../fixtures/obama.txt', File.dirname(__FILE__)
+    end
+    let(:args) { [txt_path] }
+
+    it 'returns only government domains' do
+      expected = <<~EXPECTED
+        mr.senator@obama.senate.gov
+        president@whitehouse.gov
+        commander.in.chief@us.army.mil
+      EXPECTED
+
+      expect(output).to eql(expected)
+    end
+  end
+end

data/spec/gman/country_code_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+RSpec.describe 'Gman Country Codes' do
+  {
+    'whitehouse.gov' => 'United States of America',
+    'foo.gov.uk' => 'United Kingdom of Great Britain and Northern Ireland',
+    'army.mil' => 'United States of America',
+    'foo.gc.ca' => 'Canada',
+    'foo.eu' => nil
+  }.each do |domain, expected_country|
+    context "given #{domain.inspect}" do
+      subject { Gman.new(domain) }
+
+      let(:country) { subject.country }
+
+      it 'knows the country' do
+        if expected_country.nil?
+          expect(country).to be_nil
+        else
+          expect(country.name).to eql(expected_country)
+        end
+      end
+
+      it 'knows the alpha2' do
+        expected = case expected_country
+                   when 'United States of America'
+                     'us'
+                   when 'Canada'
+                     'ca'
+                   when 'United Kingdom of Great Britain and Northern Ireland'
+                     'gb'
+                   else
+                     'eu'
+                   end
+        expect(subject.alpha2).to eql(expected)
+      end
+    end
+  end
+end

data/spec/gman/domain_list_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+RSpec.describe Gman::DomainList do
+  let(:data) { subject.data }
+  let(:canada) { data['Canada municipal'] }
+
+  %i[path contents data].each do |type|
+    context "when initialized by #{type}" do
+      subject do
+        case type
+        when :path
+          described_class.new(path: Gman.list_path)
+        when :contents
+          contents = File.read(Gman.list_path)
+          described_class.new(contents: contents)
+        when :data
+          data = described_class.new(path: Gman.list_path).to_h
+          described_class.new(data: data)
+        end
+      end
+
+      it 'stores the init var' do
+        expect(subject.send(type)).not_to be_nil
+      end
+
+      it 'returns the domain data' do
+        expect(data).to have_key('Canada federal')
+        expect(data.values.flatten).to include('gov')
+      end
+
+      it 'returns the list contents' do
+        expect(subject.contents).to match(/^gov$/)
+      end
+
+      it 'knows the list path' do
+        expect(subject.path).to eql(Gman.list_path)
+      end
+
+      it 'returns the PublicSuffix list' do
+        expect(subject.public_suffix_list).to be_a(PublicSuffix::List)
+      end
+
+      it 'knows if a domain is valid' do
+        expect(subject.valid?('whitehouse.gov')).to be(true)
+      end
+
+      it 'knows if a domain is invalid' do
+        expect(subject.valid?('example.com')).to be(false)
+      end
+
+      it 'returns the domain groups' do
+        expect(subject.groups).to include('Canada federal')
+      end
+
+      it 'returns the domains' do
+        expect(subject.domains).to include('gov')
+      end
+
+      it 'returns the domain count' do
+        expect(subject.count).to be_a(Integer)
+        expect(subject.count).to be > 100
+      end
+
+      it 'alphabetizes the list' do
+        canada.shuffle!
+        expect(canada.first).not_to eql('100milehouse.com')
+        subject.alphabetize
+        expect(canada.first).to eql('100milehouse.com')
+      end
+
+      it 'outputs public suffix format' do
+        expect(subject.to_s).to match("// Canada federal\ncanada\.ca\n")
+      end
+
+      it "finds a domain's parent" do
+        expect(subject.parent_domain('foo.gov.uk')).to eql('gov.uk')
+      end
+
+      context 'with the list path stubbed' do
+        let(:stubbed_file_contents) { File.read(stubbed_list_path) }
+
+        before do
+          subject.instance_variable_set('@path', stubbed_list_path)
+        end
+
+        context 'with list data stubbed' do
+          before do
+            subject.data = { 'foo' => ['!mail.bar.gov', 'bar.gov', 'baz.net'] }
+          end
+
+          context 'alphabetizing' do
+            before { subject.alphabetize }
+
+            it 'puts exceptions last' do
+              expect(subject.data['foo'].last).to eql('!mail.bar.gov')
+            end
+          end
+
+          context 'writing' do
+            before { subject.write }
+
+            it 'writes the contents' do
+              expect(stubbed_file_contents).to match("// foo\nbar.gov\nbaz.net")
+            end
+          end
+        end
+      end
+    end
+  end
+end

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