From cddd2647125d8dfaa6c28079d137debb1c9318af Mon Sep 17 00:00:00 2001
From: Paul Battley <pbattley@gmail.com>
Date: Fri, 30 Jan 2015 16:05:19 +0300
Subject: [PATCH] Move tests to RSpec

Mini[Tt]est is frustratingly inconsistent between versions of Ruby.
---
 .gitignore                                    |   2 +-
 .rspec                                        |   3 +
 Rakefile                                      |  11 +-
 spec/country_finder_spec.rb                   |  32 +++
 .../full_postcode_spec.rb                     |  11 +-
 spec/geographic_postcode_spec.rb              | 268 +++++++++++++++++
 spec/giro_postcode_spec.rb                    |  97 +++++++
 spec/invalid_postcode_spec.rb                 |  72 +++++
 spec/spec_helper.rb                           |   0
 .../special_postcode_spec.rb                  |  13 +-
 spec/tree_spec.rb                             |  80 ++++++
 spec/uk_postcode_spec.rb                      |  29 ++
 test/country_finder_test.rb                   |  33 ---
 test/geographic_postcode_test.rb              | 271 ------------------
 test/giro_postcode_test.rb                    | 100 -------
 test/invalid_postcode_test.rb                 |  75 -----
 test/test_helper.rb                           |   4 -
 test/tree_test.rb                             |  84 ------
 test/uk_postcode_test.rb                      |  30 --
 19 files changed, 599 insertions(+), 616 deletions(-)
 create mode 100644 .rspec
 create mode 100644 spec/country_finder_spec.rb
 rename test/full_postcode_test.rb => spec/full_postcode_spec.rb (74%)
 create mode 100644 spec/geographic_postcode_spec.rb
 create mode 100644 spec/giro_postcode_spec.rb
 create mode 100644 spec/invalid_postcode_spec.rb
 create mode 100644 spec/spec_helper.rb
 rename test/special_postcode_test.rb => spec/special_postcode_spec.rb (66%)
 create mode 100644 spec/tree_spec.rb
 create mode 100644 spec/uk_postcode_spec.rb
 delete mode 100644 test/country_finder_test.rb
 delete mode 100644 test/geographic_postcode_test.rb
 delete mode 100644 test/giro_postcode_test.rb
 delete mode 100644 test/invalid_postcode_test.rb
 delete mode 100644 test/test_helper.rb
 delete mode 100644 test/tree_test.rb
 delete mode 100644 test/uk_postcode_test.rb

diff --git a/.gitignore b/.gitignore
index c0d637d..44df20d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,4 @@
 *.gem
 Gemfile.lock
 /data/
-/test/data/
+/spec/data/
diff --git a/.rspec b/.rspec
new file mode 100644
index 0000000..250cad9
--- /dev/null
+++ b/.rspec
@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+-I lib
diff --git a/Rakefile b/Rakefile
index b3f5a98..214e6d5 100644
--- a/Rakefile
+++ b/Rakefile
@@ -1,8 +1,9 @@
-require "rake/testtask"
+require "rspec/core/rake_task"
 
-Rake::TestTask.new("test") do |t|
-  t.pattern = "test/**/*_test.rb"
-  t.verbose = true
+desc "Run the specs."
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = false
 end
 
-task default: :test
+task :default => [:spec]
diff --git a/spec/country_finder_spec.rb b/spec/country_finder_spec.rb
new file mode 100644
index 0000000..14577dd
--- /dev/null
+++ b/spec/country_finder_spec.rb
@@ -0,0 +1,32 @@
+require "uk_postcode"
+
+describe UKPostcode do
+  it "finds the country of a full postcode in England" do
+    expect(described_class.parse("W1A 1AA").country).to eq(:england)
+  end
+
+  it "finds the country of a full postcode in Scotland" do
+    expect(described_class.parse("EH8 8DX").country).to eq(:scotland)
+  end
+
+  it "finds the country of a full postcode in Wales" do
+    expect(described_class.parse("CF99 1NA").country).to eq(:wales)
+  end
+
+  it "finds the country of a full postcode in Northern Ireland" do
+    expect(described_class.parse("BT4 3XX").country).to eq(:northern_ireland)
+  end
+
+  it "finds the country of a postcode in a border region" do
+    expect(described_class.parse("CA6 5HS").country).to eq(:scotland)
+    expect(described_class.parse("CA6 5HT").country).to eq(:england)
+  end
+
+  it "finds the country of an unambiguous partial postcode" do
+    expect(described_class.parse("BT4").country).to eq(:northern_ireland)
+  end
+
+  it "returns :unknown for an ambiguous partial postcode" do
+    expect(described_class.parse("DG16").country).to eq(:unknown)
+  end
+end
diff --git a/test/full_postcode_test.rb b/spec/full_postcode_spec.rb
similarity index 74%
rename from test/full_postcode_test.rb
rename to spec/full_postcode_spec.rb
index 71ff057..7eeaad0 100644
--- a/test/full_postcode_test.rb
+++ b/spec/full_postcode_spec.rb
@@ -1,4 +1,3 @@
-require_relative "./test_helper"
 require "csv"
 require "uk_postcode"
 
@@ -14,7 +13,7 @@
     'M83000003' => :isle_of_man
   }
 
-  it "should correctly parse and find the country of every extant postcode" do
+  it "parses and finds the country of every extant postcode" do
     skip "Skipping because SKIP_FULL_TEST was set" if ENV['SKIP_FULL_TEST']
     skip "Skipping because #{CSV_PATH} does not exist" unless File.exist?(CSV_PATH)
 
@@ -25,10 +24,10 @@
 
       postcode = UKPostcode.parse(outcode + incode)
 
-      postcode.wont_be_nil
-      postcode.outcode.must_equal outcode
-      postcode.incode.must_equal incode
-      postcode.country.must_equal country
+      expect(postcode).not_to be_nil
+      expect(postcode.outcode).to eq(outcode)
+      expect(postcode.incode).to eq(incode)
+      expect(postcode.country).to eq(country)
     end
   end
 end
diff --git a/spec/geographic_postcode_spec.rb b/spec/geographic_postcode_spec.rb
new file mode 100644
index 0000000..e62070f
--- /dev/null
+++ b/spec/geographic_postcode_spec.rb
@@ -0,0 +1,268 @@
+require "uk_postcode/geographic_postcode"
+
+describe UKPostcode::GeographicPostcode do
+  describe "parse" do
+    it "parses a full postcode" do
+      pc = described_class.parse("W1A 1AA")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.area).to eq("W")
+      expect(pc.district).to eq("1A")
+      expect(pc.sector).to eq("1")
+      expect(pc.unit).to eq("AA")
+    end
+
+    it "parses a postcode with no unit" do
+      pc = described_class.parse("W1A 1")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.area).to eq("W")
+      expect(pc.district).to eq("1A")
+      expect(pc.sector).to eq("1")
+      expect(pc.unit).to be_nil
+    end
+
+    it "parses an outcode" do
+      pc = described_class.parse("W1A")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.area).to eq("W")
+      expect(pc.district).to eq("1A")
+      expect(pc.sector).to be_nil
+      expect(pc.unit).to be_nil
+    end
+
+    it "parses an area" do
+      pc = described_class.parse("W")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.area).to eq("W")
+      expect(pc.district).to be_nil
+      expect(pc.sector).to be_nil
+      expect(pc.unit).to be_nil
+    end
+
+    it "handles extra spaces" do
+      pc = described_class.parse("  W1A   1AA  ")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.to_s).to eq("W1A 1AA")
+    end
+
+    it "handles no spaces" do
+      pc = described_class.parse("W1A1AA")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.to_s).to eq("W1A 1AA")
+    end
+
+    it "is case-insensitive" do
+      pc = described_class.parse("w1a 1aa")
+      expect(pc).to be_instance_of(described_class)
+      expect(pc.to_s).to eq("W1A 1AA")
+    end
+
+    it "returns nil if unable to parse" do
+      pc = described_class.parse("Can't parse this")
+      expect(pc).to be_nil
+    end
+
+    describe "single-letter area" do
+      it "extracts area without trailing I from outcode" do
+        pc = described_class.parse("B11")
+        expect(pc.area).to eq("B")
+        expect(pc.district).to eq("11")
+      end
+
+      it "extracts area without trailing I from full postcode with space" do
+        pc = described_class.parse("E17 1AA")
+        expect(pc.area).to eq("E")
+        expect(pc.district).to eq("17")
+      end
+
+      it "extracts area without trailing I from full postcode without space" do
+        pc = described_class.parse("E171AA")
+        expect(pc.area).to eq("E")
+        expect(pc.district).to eq("17")
+      end
+    end
+
+    describe "trailing O in area" do
+      it "extracts area with trailing O from outcode" do
+        pc = described_class.parse("CO1")
+        expect(pc.area).to eq("CO")
+        expect(pc.district).to eq("1")
+      end
+
+      it "extracts area with trailing O from full postcode with space" do
+        pc = described_class.parse("CO1 1BT")
+        expect(pc.area).to eq("CO")
+        expect(pc.district).to eq("1")
+      end
+
+      it "extracts area with trailing O from full postcode without space" do
+        pc = described_class.parse("CO11BT")
+        expect(pc.area).to eq("CO")
+        expect(pc.district).to eq("1")
+      end
+    end
+
+    describe "tricky postcodes" do
+      it "parses B11 1LL" do
+        pc = described_class.parse("B111LL")
+        expect(pc.area).to eq("B")
+        expect(pc.district).to eq("11")
+        expect(pc.sector).to eq("1")
+        expect(pc.unit).to eq("LL")
+      end
+
+      it "parses BII ILL" do
+        pc = described_class.parse("BIIILL")
+        expect(pc.area).to eq("B")
+        expect(pc.district).to eq("11")
+        expect(pc.sector).to eq("1")
+        expect(pc.unit).to eq("LL")
+      end
+
+      it "parses BB11 1DJ" do
+        pc = described_class.parse("BB111DJ")
+        expect(pc.area).to eq("BB")
+        expect(pc.district).to eq("11")
+        expect(pc.sector).to eq("1")
+        expect(pc.unit).to eq("DJ")
+      end
+
+      it "parses BBII IDJ" do
+        pc = described_class.parse("BBIIIDJ")
+        expect(pc.area).to eq("BB")
+        expect(pc.district).to eq("11")
+        expect(pc.sector).to eq("1")
+        expect(pc.unit).to eq("DJ")
+      end
+
+      it "parses B10 0JP" do
+        pc = described_class.parse("B100JP")
+        expect(pc.area).to eq("B")
+        expect(pc.district).to eq("10")
+        expect(pc.sector).to eq("0")
+        expect(pc.unit).to eq("JP")
+      end
+
+      it "parses BIO OJP" do
+        pc = described_class.parse("BIOOJP")
+        expect(pc.area).to eq("B")
+        expect(pc.district).to eq("10")
+        expect(pc.sector).to eq("0")
+        expect(pc.unit).to eq("JP")
+      end
+    end
+  end
+
+  describe "area" do
+    it "is capitalised" do
+      expect(described_class.new("w", "1a", "1", "aa").area).to eq("W")
+    end
+
+    it "corrects 0 to O" do
+      expect(described_class.new("0X", "1", "0", "AB").area).to eq("OX")
+    end
+
+    it "corrects 1 to I" do
+      expect(described_class.new("1G", "1", "1", "AA").area).to eq("IG")
+    end
+  end
+
+  describe "district" do
+    it "is capitalised" do
+      expect(described_class.new("w", "1a", "1", "aa").district).to eq("1A")
+    end
+
+    it "corrects O to 0" do
+      expect(described_class.new("B", "2O", "2", "XB").district).to eq("20")
+    end
+
+    it "corrects I to 1" do
+      expect(described_class.new("B", "I", "I", "DF").district).to eq("1")
+    end
+  end
+
+  describe "sector" do
+    it "corrects O to 0" do
+      expect(described_class.new("AB", "1", "O", "DN").sector).to eq("0")
+    end
+
+    it "corrects I to 1" do
+      expect(described_class.new("W", "1A", "I", "AA").sector).to eq("1")
+    end
+  end
+
+  describe "unit" do
+    it "is capitalised" do
+      expect(described_class.new("w", "1a", "1", "aa").unit).to eq("AA")
+    end
+
+    # Note: neither I nor O appear in units
+  end
+
+  describe "outcode" do
+    it "is generated from area and district" do
+      expect(described_class.new("W", "1A").outcode).to eq("W1A")
+    end
+
+    it "is nil if missing district" do
+      expect(described_class.new("W").outcode).to be_nil
+    end
+  end
+
+  describe "incode" do
+    it "is generated from sector and unit" do
+      expect(described_class.new("W", "1A", "1", "AA").incode).to eq("1AA")
+    end
+
+    it "is nil if missing sector" do
+      expect(described_class.new("W", "1A").incode).to be_nil
+    end
+
+    it "is nil if missing unit" do
+      expect(described_class.new("W", "1A", "1").incode).to be_nil
+    end
+  end
+
+  describe "to_s" do
+    it "generates a full postcode" do
+      expect(described_class.new("W", "1A", "1", "AA").to_s).to eq("W1A 1AA")
+    end
+
+    it "generates an outcode" do
+      expect(described_class.new("W", "1A").to_s).to eq("W1A")
+    end
+
+    it "generates a postcode with no unit" do
+      expect(described_class.new("W", "1A", "1").to_s).to eq("W1A 1")
+    end
+
+    it "generates an area alone" do
+      expect(described_class.new("W").to_s).to eq("W")
+    end
+  end
+
+  describe "full?" do
+    it "is true if outcode and incode are given" do
+      expect(described_class.new("W", "1A", "1", "AA")).to be_full
+    end
+
+    it "is not true if something is missing" do
+      expect(described_class.new("W", "1A", "1")).not_to be_full
+    end
+  end
+
+  describe "valid?" do
+    it "is true" do
+      expect(described_class.new("W", "1A", "1", "AA")).to be_valid
+    end
+  end
+
+  describe "country" do
+    it "looks up the country of a full postcode" do
+      expect(described_class.new("EH", "8", "8", "DX").country).to eq(:scotland)
+    end
+
+    it "looks up the country of a partial postcode" do
+      expect(described_class.new("W", "1A").country).to eq(:england)
+    end
+  end
+end
diff --git a/spec/giro_postcode_spec.rb b/spec/giro_postcode_spec.rb
new file mode 100644
index 0000000..74de612
--- /dev/null
+++ b/spec/giro_postcode_spec.rb
@@ -0,0 +1,97 @@
+require "uk_postcode/giro_postcode"
+
+describe UKPostcode::GiroPostcode do
+  let(:subject) { described_class.instance }
+
+  describe "parse" do
+    it "parses the canonical form" do
+      pc = described_class.parse("GIR 0AA")
+      expect(pc).to be_instance_of(described_class)
+    end
+
+    it "parses transcribed 0/O and 1/I" do
+      pc = described_class.parse("G1R OAA")
+      expect(pc).to be_instance_of(described_class)
+    end
+
+    it "handles extra spaces" do
+      pc = described_class.parse("  GIR   0AA   ")
+      expect(pc).to be_instance_of(described_class)
+    end
+
+    it "handles no spaces" do
+      pc = described_class.parse("GIR0AA")
+      expect(pc).to be_instance_of(described_class)
+    end
+
+    it "is case-insensitive" do
+      pc = described_class.parse("gir 0aa")
+      expect(pc).to be_instance_of(described_class)
+    end
+
+    it "returns nil if unable to parse" do
+      pc = described_class.parse("Can't parse this")
+      expect(pc).to be_nil
+    end
+  end
+
+  describe "area" do
+    it "is nil" do
+      expect(subject.area).to be_nil
+    end
+  end
+
+  describe "district" do
+    it "is nil" do
+      expect(subject.district).to be_nil
+    end
+  end
+
+  describe "sector" do
+    it "is nil" do
+      expect(subject.sector).to be_nil
+    end
+  end
+
+  describe "unit" do
+    it "is nil" do
+      expect(subject.unit).to be_nil
+    end
+  end
+
+  describe "outcode" do
+    it "is GIR" do
+      expect(subject.outcode).to eq("GIR")
+    end
+  end
+
+  describe "incode" do
+    it "is 0AA" do
+      expect(subject.incode).to eq("0AA")
+    end
+  end
+
+  describe "to_s" do
+    it "is the canonical form" do
+      expect(subject.to_s).to eq("GIR 0AA")
+    end
+  end
+
+  describe "full?" do
+    it "is true" do
+      expect(subject).to be_full
+    end
+  end
+
+  describe "valid?" do
+    it "is true" do
+      expect(subject).to be_valid
+    end
+  end
+
+  describe "country" do
+    it "is England" do
+      expect(subject.country).to eq(:england)
+    end
+  end
+end
diff --git a/spec/invalid_postcode_spec.rb b/spec/invalid_postcode_spec.rb
new file mode 100644
index 0000000..44a5770
--- /dev/null
+++ b/spec/invalid_postcode_spec.rb
@@ -0,0 +1,72 @@
+require "uk_postcode/invalid_postcode"
+
+describe UKPostcode::InvalidPostcode do
+  let(:subject) { described_class.new("anything") }
+
+  describe "parse" do
+    it "parses anything" do
+      pc = described_class.parse("Any old junk")
+      expect(pc).to be_instance_of(described_class)
+    end
+  end
+
+  describe "area" do
+    it "is nil" do
+      expect(subject.area).to be_nil
+    end
+  end
+
+  describe "district" do
+    it "is nil" do
+      expect(subject.district).to be_nil
+    end
+  end
+
+  describe "sector" do
+    it "is nil" do
+      expect(subject.sector).to be_nil
+    end
+  end
+
+  describe "unit" do
+    it "is nil" do
+      expect(subject.unit).to be_nil
+    end
+  end
+
+  describe "outcode" do
+    it "is nil" do
+      expect(subject.outcode).to be_nil
+    end
+  end
+
+  describe "incode" do
+    it "is nil" do
+      expect(subject.incode).to be_nil
+    end
+  end
+
+  describe "to_s" do
+    it "returns the initialisation string" do
+      expect(subject.to_s).to eq("anything")
+    end
+  end
+
+  describe "full?" do
+    it "is false" do
+      expect(subject).not_to be_full
+    end
+  end
+
+  describe "valid?" do
+    it "is false" do
+      expect(subject).not_to be_valid
+    end
+  end
+
+  describe "country" do
+    it "is unknown" do
+      expect(subject.country).to eq(:unknown)
+    end
+  end
+end
diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
new file mode 100644
index 0000000..e69de29
diff --git a/test/special_postcode_test.rb b/spec/special_postcode_spec.rb
similarity index 66%
rename from test/special_postcode_test.rb
rename to spec/special_postcode_spec.rb
index 625817d..73ef6a1 100644
--- a/test/special_postcode_test.rb
+++ b/spec/special_postcode_spec.rb
@@ -1,7 +1,6 @@
-require_relative "./test_helper"
 require "uk_postcode"
 
-describe "Special postcodes" do
+describe UKPostcode do
   # Special postcodes listed in http://en.wikipedia.org/wiki/UK_postcode
   SPECIAL = %w[
     SW1A 0AA
@@ -40,11 +39,11 @@
   ]
 
   SPECIAL.each_slice(2) do |outcode, incode|
-    it "should correctly handle special postcode #{outcode} #{incode}" do
-      postcode = UKPostcode.parse(outcode + incode)
-      postcode.wont_be_nil
-      postcode.outcode.must_equal outcode
-      postcode.incode.must_equal incode
+    it "handles special postcode #{outcode} #{incode}" do
+      postcode = described_class.parse(outcode + incode)
+      expect(postcode).not_to be_nil
+      expect(postcode.outcode).to eq(outcode)
+      expect(postcode.incode).to eq(incode)
     end
   end
 end
diff --git a/spec/tree_spec.rb b/spec/tree_spec.rb
new file mode 100644
index 0000000..51a3f4a
--- /dev/null
+++ b/spec/tree_spec.rb
@@ -0,0 +1,80 @@
+require "uk_postcode/tree"
+
+describe UKPostcode::Tree do
+  subject { described_class.new }
+
+  it "builds a nested hash via insert" do
+    subject.insert %w[a b c d e], :foo
+    subject.insert %w[a b c d f], :bar
+    subject.insert %w[a b g h i], :baz
+
+    expected = {
+      "a" => {
+        "b" => {
+          "c" => { "d" => { "e" => :foo, "f" => :bar } },
+          "g" => { "h" => { "i" => :baz } }
+        }
+      }
+    }
+
+    expect(subject.to_h).to eq expected
+  end
+
+  it "compresses paths to identical leaves" do
+    subject.insert %w[a b c d e], :foo
+    subject.insert %w[a b c d f], :foo
+    subject.insert %w[a b g h i], :baz
+
+    expected = {
+      "a" => {
+        "b" => {
+          "c" => :foo,
+          "g" => :baz
+        }
+      }
+    }
+
+    expect(subject.compress.to_h).to eq(expected)
+  end
+
+  it "filters the tree to include only paths to specific leaf values" do
+    subject.insert %w[a b c d e], :foo
+    subject.insert %w[a b c d f], :bar
+    subject.insert %w[a b g h i], :baz
+
+    expected = {
+      "a" => {
+        "b" => {
+          "c" => { "d" => { "e" => :foo } }
+        }
+      }
+    }
+
+    expect(subject.filter(:foo).to_h).to eq(expected)
+  end
+
+  it "generates a minimal regular expression for the tree" do
+    subject.insert %w[a b c d e], :foo
+    subject.insert %w[a b c d f], :foo
+    subject.insert %w[a b g h i], :foo
+    subject.insert %w[j k], :foo
+
+    expected = /^(?:ab(?:cd[ef]|ghi)|jk)/
+
+    expect(subject.regexp).to eq(expected)
+  end
+
+  it "generates a working regular expression for the tree" do
+    subject.insert %w[a b c d e], :foo
+    subject.insert %w[a b c d f], :foo
+    subject.insert %w[a b g h i], :foo
+    subject.insert %w[j k], :foo
+
+    regexp = subject.regexp
+    expect(regexp).to match('abcde')
+    expect(regexp).to match('abcdf')
+    expect(regexp).to match('abghi')
+    expect(regexp).to match('jk')
+    expect(regexp).not_to match('abcdg')
+  end
+end
diff --git a/spec/uk_postcode_spec.rb b/spec/uk_postcode_spec.rb
new file mode 100644
index 0000000..af72640
--- /dev/null
+++ b/spec/uk_postcode_spec.rb
@@ -0,0 +1,29 @@
+require "uk_postcode"
+
+describe UKPostcode do
+  describe "parse" do
+    it "returns a Giro postcode" do
+      subject = described_class.parse("GIR 0AA")
+      expect(subject).to be_instance_of(UKPostcode::GiroPostcode)
+      expect(subject.to_s).to eq("GIR 0AA")
+    end
+
+    it "returns a geographic postcode" do
+      subject = described_class.parse("EH8 8DX")
+      expect(subject).to be_instance_of(UKPostcode::GeographicPostcode)
+      expect(subject.to_s).to eq("EH8 8DX")
+    end
+
+    it "returns invalid instance for a blank postcode" do
+      subject = described_class.parse("")
+      expect(subject).to be_instance_of(UKPostcode::InvalidPostcode)
+      expect(subject.to_s).to eq("")
+    end
+
+    it "returns invalid instance for an invalid postcode" do
+      subject = described_class.parse("ABC DEF")
+      expect(subject).to be_instance_of(UKPostcode::InvalidPostcode)
+      expect(subject.to_s).to eq("ABC DEF")
+    end
+  end
+end
diff --git a/test/country_finder_test.rb b/test/country_finder_test.rb
deleted file mode 100644
index af710b1..0000000
--- a/test/country_finder_test.rb
+++ /dev/null
@@ -1,33 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode"
-
-describe UKPostcode do
-  it 'should find the country of a full postcode in England' do
-    UKPostcode.parse('W1A 1AA').country.must_equal :england
-  end
-
-  it 'should find the country of a full postcode in Scotland' do
-    UKPostcode.parse('EH8 8DX').country.must_equal :scotland
-  end
-
-  it 'should find the country of a full postcode in Wales' do
-    UKPostcode.parse('CF99 1NA').country.must_equal :wales
-  end
-
-  it 'should find the country of a full postcode in Northern Ireland' do
-    UKPostcode.parse('BT4 3XX').country.must_equal :northern_ireland
-  end
-
-  it 'should find the country of a postcode in a border region' do
-    UKPostcode.parse('CA6 5HS').country.must_equal :scotland
-    UKPostcode.parse('CA6 5HT').country.must_equal :england
-  end
-
-  it 'should find the country of an unambiguous partial postcode' do
-    UKPostcode.parse('BT4').country.must_equal :northern_ireland
-  end
-
-  it 'should return :unknown for an ambiguous partial postcode' do
-    UKPostcode.parse('DG16').country.must_equal :unknown
-  end
-end
diff --git a/test/geographic_postcode_test.rb b/test/geographic_postcode_test.rb
deleted file mode 100644
index 2cf19b0..0000000
--- a/test/geographic_postcode_test.rb
+++ /dev/null
@@ -1,271 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/geographic_postcode"
-
-describe UKPostcode::GeographicPostcode do
-  described_class = UKPostcode::GeographicPostcode
-
-  describe "parse" do
-    it "should parse a full postcode" do
-      pc = described_class.parse("W1A 1AA")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_equal "1A"
-      pc.sector.must_equal "1"
-      pc.unit.must_equal "AA"
-    end
-
-    it "should parse a postcode with no unit" do
-      pc = described_class.parse("W1A 1")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_equal "1A"
-      pc.sector.must_equal "1"
-      pc.unit.must_be_nil
-    end
-
-    it "should parse an outcode" do
-      pc = described_class.parse("W1A")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_equal "1A"
-      pc.sector.must_be_nil
-      pc.unit.must_be_nil
-    end
-
-    it "should parse an area" do
-      pc = described_class.parse("W")
-      pc.must_be_instance_of described_class
-      pc.area.must_equal "W"
-      pc.district.must_be_nil
-      pc.sector.must_be_nil
-      pc.unit.must_be_nil
-    end
-
-    it "should handle extra spaces" do
-      pc = described_class.parse("  W1A   1AA  ")
-      pc.must_be_instance_of described_class
-      pc.to_s.must_equal "W1A 1AA"
-    end
-
-    it "should handle no spaces" do
-      pc = described_class.parse("W1A1AA")
-      pc.must_be_instance_of described_class
-      pc.to_s.must_equal "W1A 1AA"
-    end
-
-    it "should be case-insensitive" do
-      pc = described_class.parse("w1a 1aa")
-      pc.must_be_instance_of described_class
-      pc.to_s.must_equal "W1A 1AA"
-    end
-
-    it "should return nil if unable to parse" do
-      pc = described_class.parse("Can't parse this")
-      pc.must_be_nil
-    end
-
-    describe "single-letter area" do
-      it "should extract area without trailing I from outcode" do
-        pc = described_class.parse("B11")
-        pc.area.must_equal "B"
-        pc.district.must_equal "11"
-      end
-
-      it "should extract area without trailing I from full postcode with space" do
-        pc = described_class.parse("E17 1AA")
-        pc.area.must_equal "E"
-        pc.district.must_equal "17"
-      end
-
-      it "should extract area without trailing I from full postcode without space" do
-        pc = described_class.parse("E171AA")
-        pc.area.must_equal "E"
-        pc.district.must_equal "17"
-      end
-    end
-
-    describe "trailing O in area" do
-      it "should extract area with trailing O from outcode" do
-        pc = described_class.parse("CO1")
-        pc.area.must_equal "CO"
-        pc.district.must_equal "1"
-      end
-
-      it "should extract area with trailing O from full postcode with space" do
-        pc = described_class.parse("CO1 1BT")
-        pc.area.must_equal "CO"
-        pc.district.must_equal "1"
-      end
-
-      it "should extract area with trailing O from full postcode without space" do
-        pc = described_class.parse("CO11BT")
-        pc.area.must_equal "CO"
-        pc.district.must_equal "1"
-      end
-    end
-
-    describe "tricky postcodes" do
-      it "should parse B11 1LL" do
-        pc = described_class.parse("B111LL")
-        pc.area.must_equal "B"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "LL"
-      end
-
-      it "should parse BII ILL" do
-        pc = described_class.parse("BIIILL")
-        pc.area.must_equal "B"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "LL"
-      end
-
-      it "should parse BB11 1DJ" do
-        pc = described_class.parse("BB111DJ")
-        pc.area.must_equal "BB"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "DJ"
-      end
-
-      it "should parse BBII IDJ" do
-        pc = described_class.parse("BBIIIDJ")
-        pc.area.must_equal "BB"
-        pc.district.must_equal "11"
-        pc.sector.must_equal "1"
-        pc.unit.must_equal "DJ"
-      end
-
-      it "should parse B10 0JP" do
-        pc = described_class.parse("B100JP")
-        pc.area.must_equal "B"
-        pc.district.must_equal "10"
-        pc.sector.must_equal "0"
-        pc.unit.must_equal "JP"
-      end
-
-      it "should parse BIO OJP" do
-        pc = described_class.parse("BIOOJP")
-        pc.area.must_equal "B"
-        pc.district.must_equal "10"
-        pc.sector.must_equal "0"
-        pc.unit.must_equal "JP"
-      end
-    end
-  end
-
-  describe "area" do
-    it "should be capitalised" do
-      described_class.new("w", "1a", "1", "aa").area.must_equal "W"
-    end
-
-    it "should correct 0 to O" do
-      described_class.new("0X", "1", "0", "AB").area.must_equal "OX"
-    end
-
-    it "should correct 1 to I" do
-      described_class.new("1G", "1", "1", "AA").area.must_equal "IG"
-    end
-  end
-
-  describe "district" do
-    it "should be capitalised" do
-      described_class.new("w", "1a", "1", "aa").district.must_equal "1A"
-    end
-
-    it "should correct O to 0" do
-      described_class.new("B", "2O", "2", "XB").district.must_equal "20"
-    end
-
-    it "should correct I to 1" do
-      described_class.new("B", "I", "I", "DF").district.must_equal "1"
-    end
-  end
-
-  describe "sector" do
-    it "should correct O to 0" do
-      described_class.new("AB", "1", "O", "DN").sector.must_equal "0"
-    end
-
-    it "should correct I to 1" do
-      described_class.new("W", "1A", "I", "AA").sector.must_equal "1"
-    end
-  end
-
-  describe "unit" do
-    it "should be capitalised" do
-      described_class.new("w", "1a", "1", "aa").unit.must_equal "AA"
-    end
-
-    # Note: neither I nor O appear in units
-  end
-
-  describe "outcode" do
-    it "should be generated from area and district" do
-      described_class.new("W", "1A").outcode.must_equal "W1A"
-    end
-
-    it "should be nil if missing district" do
-      described_class.new("W").outcode.must_be_nil
-    end
-  end
-
-  describe "incode" do
-    it "should be generated from sector and unit" do
-      described_class.new("W", "1A", "1", "AA").incode.must_equal "1AA"
-    end
-
-    it "should be nil if missing sector" do
-      described_class.new("W", "1A").incode.must_be_nil
-    end
-
-    it "should be nil if missing unit" do
-      described_class.new("W", "1A", "1").incode.must_be_nil
-    end
-  end
-
-  describe "to_s" do
-    it "should generate a full postcode" do
-      described_class.new("W", "1A", "1", "AA").to_s.must_equal "W1A 1AA"
-    end
-
-    it "should generate an outcode" do
-      described_class.new("W", "1A").to_s.must_equal "W1A"
-    end
-
-    it "should generate a postcode with no unit" do
-      described_class.new("W", "1A", "1").to_s.must_equal "W1A 1"
-    end
-
-    it "should generate an area alone" do
-      described_class.new("W").to_s.must_equal "W"
-    end
-  end
-
-  describe "full?" do
-    it "should be true if outcode and incode are given" do
-      described_class.new("W", "1A", "1", "AA").must_be :full?
-    end
-
-    it "should not be true if something is missing" do
-      described_class.new("W", "1A", "1").wont_be :full?
-    end
-  end
-
-  describe "valid?" do
-    it "should be true" do
-      described_class.new("W", "1A", "1", "AA").must_be :valid?
-    end
-  end
-
-  describe "country" do
-    it "should look up the country of a full postcode" do
-      described_class.new("EH", "8", "8", "DX").country.must_equal :scotland
-    end
-
-    it "should look up the country of a partial postcode" do
-      described_class.new("W", "1A").country.must_equal :england
-    end
-  end
-end
diff --git a/test/giro_postcode_test.rb b/test/giro_postcode_test.rb
deleted file mode 100644
index 81bbe7f..0000000
--- a/test/giro_postcode_test.rb
+++ /dev/null
@@ -1,100 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/giro_postcode"
-
-describe UKPostcode::GiroPostcode do
-  described_class = UKPostcode::GiroPostcode
-
-  let(:subject) { described_class.instance }
-
-  describe "parse" do
-    it "should parse the canonical form" do
-      pc = described_class.parse("GIR 0AA")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should parse transcribed 0/O and 1/I" do
-      pc = described_class.parse("G1R OAA")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should handle extra spaces" do
-      pc = described_class.parse("  GIR   0AA   ")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should handle no spaces" do
-      pc = described_class.parse("GIR0AA")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should be case-insensitive" do
-      pc = described_class.parse("gir 0aa")
-      pc.must_be_instance_of described_class
-    end
-
-    it "should return nil if unable to parse" do
-      pc = described_class.parse("Can't parse this")
-      pc.must_be_nil
-    end
-  end
-
-  describe "area" do
-    it "should be nil" do
-      subject.area.must_be_nil
-    end
-  end
-
-  describe "district" do
-    it "should be nil" do
-      subject.district.must_be_nil
-    end
-  end
-
-  describe "sector" do
-    it "should be nil" do
-      subject.sector.must_be_nil
-    end
-  end
-
-  describe "unit" do
-    it "should be nil" do
-      subject.unit.must_be_nil
-    end
-  end
-
-  describe "outcode" do
-    it "should be GIR" do
-      subject.outcode.must_equal("GIR")
-    end
-  end
-
-  describe "incode" do
-    it "should be 0AA" do
-      subject.incode.must_equal("0AA")
-    end
-  end
-
-  describe "to_s" do
-    it "should be the canonical form" do
-      subject.to_s.must_equal "GIR 0AA"
-    end
-  end
-
-  describe "full?" do
-    it "should be true" do
-      subject.must_be :full?
-    end
-  end
-
-  describe "valid?" do
-    it "should be true" do
-      subject.must_be :valid?
-    end
-  end
-
-  describe "country" do
-    it "should be England" do
-      subject.country.must_equal :england
-    end
-  end
-end
diff --git a/test/invalid_postcode_test.rb b/test/invalid_postcode_test.rb
deleted file mode 100644
index 480e7eb..0000000
--- a/test/invalid_postcode_test.rb
+++ /dev/null
@@ -1,75 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/invalid_postcode"
-
-describe UKPostcode::InvalidPostcode do
-  described_class = UKPostcode::InvalidPostcode
-
-  let(:subject) { described_class.new("anything") }
-
-  describe "parse" do
-    it "should parse anything" do
-      pc = described_class.parse("Any old junk")
-      pc.must_be_instance_of described_class
-    end
-  end
-
-  describe "area" do
-    it "should be nil" do
-      subject.area.must_be_nil
-    end
-  end
-
-  describe "district" do
-    it "should be nil" do
-      subject.district.must_be_nil
-    end
-  end
-
-  describe "sector" do
-    it "should be nil" do
-      subject.sector.must_be_nil
-    end
-  end
-
-  describe "unit" do
-    it "should be nil" do
-      subject.unit.must_be_nil
-    end
-  end
-
-  describe "outcode" do
-    it "should be nil" do
-      subject.outcode.must_be_nil
-    end
-  end
-
-  describe "incode" do
-    it "should be nil" do
-      subject.incode.must_be_nil
-    end
-  end
-
-  describe "to_s" do
-    it "should return the initialisation string" do
-      subject.to_s.must_equal "anything"
-    end
-  end
-
-  describe "full?" do
-    it "should be false" do
-      subject.wont_be :full?
-    end
-  end
-
-  describe "valid?" do
-    it "should be false" do
-      subject.wont_be :valid?
-    end
-  end
-
-  describe "country" do
-    it "should be unknown" do
-      subject.country.must_equal :unknown
-    end
-  end
-end
diff --git a/test/test_helper.rb b/test/test_helper.rb
deleted file mode 100644
index e0180ff..0000000
--- a/test/test_helper.rb
+++ /dev/null
@@ -1,4 +0,0 @@
-lib = File.expand_path("../../lib", __FILE__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
-require "minitest/spec"
-require "minitest/autorun"
diff --git a/test/tree_test.rb b/test/tree_test.rb
deleted file mode 100644
index d9526e0..0000000
--- a/test/tree_test.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode/tree"
-
-describe UKPostcode::Tree do
-  it "should build a nested hash via insert" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :bar
-    tree.insert %w[a b g h i], :baz
-
-    expected = {
-      "a" => {
-        "b" => {
-          "c" => { "d" => { "e" => :foo, "f" => :bar } },
-          "g" => { "h" => { "i" => :baz } }
-        }
-      }
-    }
-
-    tree.to_h.must_equal expected
-  end
-
-  it "should compress paths to identical leaves" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :foo
-    tree.insert %w[a b g h i], :baz
-
-    expected = {
-      "a" => {
-        "b" => {
-          "c" => :foo,
-          "g" => :baz
-        }
-      }
-    }
-
-    tree.compress.to_h.must_equal expected
-  end
-
-  it "should filter the tree to include only paths to specific leaf values" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :bar
-    tree.insert %w[a b g h i], :baz
-
-    expected = {
-      "a" => {
-        "b" => {
-          "c" => { "d" => { "e" => :foo } }
-        }
-      }
-    }
-
-    tree.filter(:foo).to_h.must_equal expected
-  end
-
-  it "should generate a minimal regular expression for the tree" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :foo
-    tree.insert %w[a b g h i], :foo
-    tree.insert %w[j k], :foo
-
-    expected = /^(?:ab(?:cd[ef]|ghi)|jk)/
-
-    tree.regexp.must_equal expected
-  end
-
-  it "should generate a working regular expression for the tree" do
-    tree = UKPostcode::Tree.new
-    tree.insert %w[a b c d e], :foo
-    tree.insert %w[a b c d f], :foo
-    tree.insert %w[a b g h i], :foo
-    tree.insert %w[j k], :foo
-
-    regexp = tree.regexp
-    regexp.must_be :match, 'abcde'
-    regexp.must_be :match, 'abcdf'
-    regexp.must_be :match, 'abghi'
-    regexp.must_be :match, 'jk'
-    regexp.wont_be :match, 'abcdg'
-  end
-end
diff --git a/test/uk_postcode_test.rb b/test/uk_postcode_test.rb
deleted file mode 100644
index 32eefbc..0000000
--- a/test/uk_postcode_test.rb
+++ /dev/null
@@ -1,30 +0,0 @@
-require_relative "./test_helper"
-require "uk_postcode"
-
-describe UKPostcode do
-  describe "parse" do
-    it "should return a Giro postcode" do
-      pc = UKPostcode.parse("GIR 0AA")
-      pc.must_be_instance_of UKPostcode::GiroPostcode
-      pc.to_s.must_equal "GIR 0AA"
-    end
-
-    it "should return a geographic postcode" do
-      pc = UKPostcode.parse("EH8 8DX")
-      pc.must_be_instance_of UKPostcode::GeographicPostcode
-      pc.to_s.must_equal "EH8 8DX"
-    end
-
-    it "should return invalid instance for a blank postcode" do
-      pc = UKPostcode.parse("")
-      pc.must_be_instance_of UKPostcode::InvalidPostcode
-      pc.to_s.must_equal ""
-    end
-
-    it "should return invalid instance for an invalid postcode" do
-      pc = UKPostcode.parse("ABC DEF")
-      pc.must_be_instance_of UKPostcode::InvalidPostcode
-      pc.to_s.must_equal "ABC DEF"
-    end
-  end
-end