gman 7.0.1 → 7.0.2

data/spec/gman/identifier_spec.rb

@@ -0,0 +1,182 @@
+RSpec.describe 'Gman identifier' do
+  let(:domain) { '' }
+  subject { Gman.new(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 eql(:state)
+      end
+
+      it 'knows the state' do
+        expect(subject.state).to eql('AK')
+      end
+
+      it "knows it's not a dotgov" do
+        expect(subject).to_not be_a_dotgov
+      end
+
+      it "know's it's not a city" do
+        expect(subject).to_not be_a_city
+      end
+
+      it "know's it's not a county" do
+        expect(subject).to_not 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 eql(:city)
+      end
+
+      it 'knows the state' do
+        expect(subject.state).to eql('IL')
+      end
+
+      it "knows it's not a dotgov" do
+        expect(subject).to_not be_a_dotgov
+      end
+
+      it "know's it's not a state" do
+        expect(subject).to_not be_a_state
+      end
+
+      it "know's it's not a county" do
+        expect(subject).to_not 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 eql(: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).to_not be_a_city
+        end
+
+        it "knows it's not a state" do
+          expect(subject).to_not be_a_state
+        end
+
+        it "knows it's not a county" do
+          expect(subject).to_not 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
+      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 eql(: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).to_not be_a_city
+        end
+
+        it "knows it's not federal" do
+          expect(subject).to_not be_federal
+        end
+
+        it "knows it's not a county" do
+          expect(subject).to_not 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 eql(: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).to_not be_a_city
+        end
+
+        it "knows it's not federal" do
+          expect(subject).to_not be_federal
+        end
+
+        it "knows it's not a state" do
+          expect(subject).to_not 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
+    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,227 @@
+RSpec.describe Gman::Importer do
+  let(:domains) { { 'test' => ['example.com'] } }
+  let(:stdout) { StringIO.new }
+  let(:logger) { Logger.new(@stdout) }
+  let(:domain_list) { subject.domain_list }
+  subject { described_class.new(domains) }
+
+  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 eql(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 eql(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 eql(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 eql(true)
+      end
+    end
+
+    {
+      :empty       => '',
+      :blacklisted => 'egovlink.com',
+      :invalid     => 'foo.invalid',
+      :academic    => 'harvard.edu',
+      :"rejex'd"   => 'foo.github.io'
+    }.each do |type, _domain|
+      context "a #{type} domain" do
+        it 'is invalid' do
+          expect(valid?).to eql(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

data/spec/gman/locality_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Gman::Locality do
+  context 'valid domains' do
+    ['foo.state.il.us', 'ci.foo.il.us'].each do |domain|
+      context "the #{domain} domain" do
+        it 'is valid' do
+          expect(described_class.valid?(domain)).to eql(true)
+        end
+      end
+    end
+  end
+
+  context 'invalid domains' do
+    ['state.foo.il.us', 'foo.ci.il.us',
+     'k12.il.us', 'ci.foo.zx.us'].each do |domain|
+       context "the #{domain} domain" do
+         it 'is invalid' do
+           expect(described_class.valid?(domain)).to eql(false)
+         end
+       end
+     end
+  end
+end

data/spec/gman_spec.rb

@@ -0,0 +1,72 @@
+RSpec.describe Gman do
+  context 'valid domains' do
+    ['foo.gov', 'http://foo.mil', 'foo@bar.gc.ca', 'foo.gov.au',
+     'https://www.foo.gouv.fr', 'foo@ci.champaign.il.us',
+     'foo.bar.baz.gov.au', 'foo@bar.gov.uk', 'foo.gov',
+     'foo.fed.us', 'foo.state.il.us', 'state.il.us',
+     'foo@af.mil', 'foo.gov.in'].each do |domain|
+       subject { described_class.new(domain) }
+
+       it "knows #{domain.inspect} is valid government domain" do
+         expect(described_class.valid?(domain)).to eql(true)
+         expect(subject.valid?).to eql(true)
+       end
+     end
+  end
+
+  context 'invalid domains' do
+    ['foo.bar.com', 'bar@foo.biz', 'http://www.foo.biz',
+     'foo.uk', 'gov', 'foo@k12.champaign.il.us', 'foo@kii.gov.by',
+     'foo', '', nil, ' ', 'foo.city.il.us', 'foo.ci.il.us',
+     'foo.zx.us', 'foo@mail.gov.ua', 'foo@gwu.edu'].each do |domain|
+      subject { described_class.new(domain) }
+
+      it "knows #{domain.inspect} is not a valid government domain" do
+        expect(described_class.valid?(domain)).to eql(false)
+        expect(subject.valid?).to eql(false)
+      end
+    end
+  end
+
+  context 'localities' do
+    subject { described_class.new(domain) }
+
+    context 'when given github.gov' do
+      let(:domain) { 'github.gov' }
+
+      it "knows it's not a locality" do
+        expect(subject.locality?).to eql(false)
+      end
+    end
+
+    context 'when given foo.state.il.us' do
+      let(:domain) { 'foo.state.il.us' }
+
+      it "knows it's a locality" do
+        expect(subject.locality?).to eql(true)
+      end
+    end
+  end
+
+  context 'class methods' do
+    it 'returns the domain list' do
+      expect(described_class.list).to be_a(Gman::DomainList)
+    end
+
+    it 'returns the academic list' do
+      expect(described_class.academic_list).to be_a(Gman::DomainList)
+    end
+
+    it 'returns the config path' do
+      expect(Dir.exist?(described_class.config_path)).to eql(true)
+    end
+
+    it 'returns the list path' do
+      expect(File.exist?(described_class.list_path)).to eql(true)
+    end
+
+    it 'returns the academic list path' do
+      expect(File.exist?(described_class.academic_list_path)).to eql(true)
+    end
+  end
+end