gman 7.0.5 → 8.0.0

data/spec/gman/importer_spec.rb

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

data/spec/gman/locality_spec.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-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 be(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 be(false)
-         end
-       end
-     end
-  end
-end

data/spec/gman_spec.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-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 be(true)
-         expect(subject.valid?).to be(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 be(false)
-        expect(subject.valid?).to be(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 be(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 be(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 be(true)
-    end
-
-    it 'returns the list path' do
-      expect(File.exist?(described_class.list_path)).to be(true)
-    end
-
-    it 'returns the academic list path' do
-      expect(File.exist?(described_class.academic_list_path)).to be(true)
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'parallel'
-require 'open3'
-
-RSpec.configure do |config|
-  config.example_status_persistence_file_path = 'spec/examples.txt'
-  config.disable_monkey_patching!
-  config.default_formatter = 'doc' if config.files_to_run.one?
-  config.order = :random
-  Kernel.srand config.seed
-end
-
-require_relative '../lib/gman'
-require_relative '../lib/gman/domain_list'
-require_relative '../lib/gman/importer'
-
-def fixture_path(fixture)
-  File.expand_path "./fixtures/#{fixture}", File.dirname(__FILE__)
-end
-
-def stubbed_list_path
-  File.expand_path './fixtures/domains.txt', File.dirname(__FILE__)
-end
-
-def with_env(key, value)
-  old_env = ENV[key]
-  ENV[key] = value
-  yield
-  ENV[key] = old_env
-end