ghost 0.3.0 → 1.0.0.pre

data/spec/ghost/cli/task/empty_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  describe "empty" do
+    before do
+      store.add(Ghost::Host.new("xyz", "127.0.0.1"))
+    end
+
+    it 'empties the list of hosts' do
+      ghost("empty")
+      store.all.should be_empty
+    end
+
+    it 'outputs a summary of the operation' do
+      ghost("empty").should == "[Emptying] Done.\n"
+    end
+  end
+end

data/spec/ghost/cli/task/export_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  describe "export" do
+    it "outputs all hosts one-per-line in hosts file format" do
+      store.add Ghost::Host.new("gist.github.com", "10.0.0.1")
+      store.add Ghost::Host.new("google.com", "192.168.1.10")
+
+      ghost("export").should == <<-EOE.unindent
+        10.0.0.1 gist.github.com
+        192.168.1.10 google.com
+        EOE
+    end
+  end
+end

data/spec/ghost/cli/task/help_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  describe "help" do
+    let(:overview) do
+      <<-EOF.unindent
+        USAGE: ghost <task> [<args>]
+
+        The ghost tasks are:
+          add        Add a host
+          delete     Remove a ghost-managed host
+          empty      Clear all ghost-managed hosts
+          export     Export all hosts in /etc/hosts format
+          import     Import hosts in /etc/hosts format
+          list       Show all (or a filtered) list of hosts
+
+        See 'ghost help <task>' for more information on a specific task.
+      EOF
+    end
+
+    it 'displays help overview when called with no args' do
+      ghost("").should == overview
+    end
+
+    it 'displays help overview when help task is called with no arguments' do
+      ghost("help").should == overview
+    end
+
+    context "when no help text for a given topic is available" do
+      it "prints out a message" do
+        ghost("help missing").should == "No help for task 'missing'\n"
+      end
+    end
+  end
+end

data/spec/ghost/cli/task/import_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  describe "import" do
+    context "with current export format" do
+      let(:import) do
+        <<-EOI.unindent
+        1.2.3.4 foo.com
+        2.3.4.5 bar.com
+        EOI
+      end
+
+      let(:foo_com) { Ghost::Host.new('foo.com', '1.2.3.4') }
+      let(:bar_com) { Ghost::Host.new('bar.com', '2.3.4.5') }
+
+      context 'with no file name'
+      context 'with STDIN pseudo file name (-)'
+
+      context 'with a file name' do
+        it 'adds each entry' do
+          file = Tempfile.new('import')
+          file.write(import)
+          file.close
+
+          ghost("import #{file.path}")
+
+          store.all.should include(foo_com)
+          store.all.should include(bar_com)
+        end
+      end
+
+      context 'with multiple file names'
+
+      context 'when an entry is already present' do
+        context 'without the -f flag' do
+          it 'skips the existing entries'
+          it 'prints a warning about skipped entries'
+        end
+
+        context 'with the -f flag' do
+          it 'overwrites the existing entries'
+        end
+      end
+
+      context 'with multiple hosts per line' do
+        let(:import) do
+          <<-EOI.unindent
+          1.2.3.4 foo.com
+          2.3.4.5 bar.com subdomain.bar.com
+          EOI
+        end
+      end
+    end
+  end
+end

data/spec/ghost/cli/task/list_spec.rb

@@ -0,0 +1,50 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper.rb")
+require 'ghost/cli'
+
+describe Ghost::Cli, :type => :cli do
+  describe "list" do
+    before do
+      store.add Ghost::Host.new("gist.github.com", "10.0.0.1")
+      store.add Ghost::Host.new("google.com", "192.168.1.10")
+    end
+
+    context "with no filtering parameter" do
+      it "outputs all hostnames" do
+        ghost("list").should == <<-EOF.unindent
+          Listing 2 host(s):
+            gist.github.com -> 10.0.0.1
+                 google.com -> 192.168.1.10
+          EOF
+      end
+    end
+
+    context "with a filtering parameter" do
+      before do
+        store.empty
+        store.add Ghost::Host.new("google.com", "10.0.0.1")
+        store.add Ghost::Host.new("google.co.uk", "192.168.1.10")
+        store.add Ghost::Host.new("gmail.com")
+      end
+
+      context 'that is a regex' do
+        it "outputs entries whose hostname or IP match the filter" do
+          ghost("list /\.com$/").should == <<-EOF.unindent
+            Listing 2 host(s):
+              google.com -> 10.0.0.1
+               gmail.com -> 127.0.0.1
+            EOF
+        end
+      end
+
+      context 'that is a string' do
+        it "outputs entries whose hostname or IP match the filter" do
+          ghost("list google").should == <<-EOF.unindent
+            Listing 2 host(s):
+                google.com -> 10.0.0.1
+              google.co.uk -> 192.168.1.10
+            EOF
+        end
+      end
+    end
+  end
+end

data/spec/ghost/cli_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper.rb")
+require 'ghost/cli'
+
+# TODO: test exit statuses
+describe Ghost::Cli, :type => :cli do
+  context 'writable operations with out proper permissions' do
+    it 'outputs a message telling user to escalate permissions' do
+      store.stub(:add).and_raise(Errno::EACCES)
+
+      ghost("add domain.com").should == "Insufficient privileges. Try using `sudo` or running as root.\n"
+    end
+  end
+
+  describe "environment configuration" # via GHOST_OPTS (see OptionParser#environment)
+
+  describe "--version" do
+    it "outputs the gem name and version" do
+      ghost("--version").should == "ghost #{Ghost::VERSION}\n"
+      ghost("-v").should == "ghost #{Ghost::VERSION}\n"
+    end
+  end
+end

data/spec/ghost/host_spec.rb

@@ -0,0 +1,36 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper.rb")
+require 'ghost/host'
+
+describe Ghost::Host do
+  describe 'attributes' do
+    subject { Ghost::Host.new('google.com', '74.125.225.102') }
+
+    its(:name)       { should == 'google.com' }
+    its(:to_s)       { should == 'google.com' }
+    its(:host)       { should == 'google.com' }
+    its(:hostname)   { should == 'google.com' }
+    its(:ip)         { should == '74.125.225.102'}
+    its(:ip_address) { should == '74.125.225.102'}
+  end
+
+  it 'has a default IP of 127.0.0.1' do
+    Ghost::Host.new('xyz.com').ip.should == '127.0.0.1'
+  end
+
+  describe 'equality' do
+    it 'is equal to a host with the same hostname and IP' do
+      Ghost::Host.new('google.com', '123.123.123.123').should ==
+        Ghost::Host.new('google.com', '123.123.123.123')
+    end
+
+    it 'is not equal to a host with a different host name' do
+      Ghost::Host.new('google.com', '123.123.123.123').should_not ==
+        Ghost::Host.new('gmail.com', '123.123.123.123')
+    end
+
+    it 'is not equal to a host with a different IP' do
+      Ghost::Host.new('google.com', '123.123.123.123').should_not ==
+        Ghost::Host.new('google.com', '222.222.222.222')
+    end
+  end
+end

data/spec/ghost/store/dscl_store_spec.rb

@@ -0,0 +1,153 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper.rb")
+require 'ghost/store/dscl_store'
+
+# TODO: Raise exception error when `dscl` doesn't have sufficient privileges
+describe Ghost::Store::DsclStore do
+  let(:store) { Ghost::Store::DsclStore.new }
+  let(:cmd)   { Ghost::Store::DsclStore::Dscl }
+
+  before do
+    cmd.stub(:list => [])
+    cmd.stub(:read => nil)
+    cmd.stub(:create => true)
+    cmd.stub(:delete => true)
+  end
+
+  let(:dscl_foo_com) do
+    <<-EOF.unindent
+    AppleMetaNodeLocation: /Local/Default
+    GeneratedUID: 7FE20A09-21B5-42C5-9E8C-E64999BD20E2
+    IPAddress: 123.123.123.123
+    RecordName: foo.com
+    RecordType: dsRecTypeStandard:Hosts
+    EOF
+  end
+
+  let(:dscl_bar_com) do
+    <<-EOF.unindent
+    AppleMetaNodeLocation: /Local/Default
+    GeneratedUID: 15286594-C5F1-4508-BAB0-98B96D424657
+    IPAddress: 127.0.0.1
+    RecordName: bar.com
+    RecordType: dsRecTypeStandard:Hosts
+    EOF
+  end
+
+  describe "#all" do
+    it 'returns an empty array when no hosts are in the store' do
+      store.all.should == []
+    end
+
+    it 'returns an array of Ghost::Host entries for each host in the store' do
+      cmd.stub(:list).and_return([dscl_foo_com, dscl_bar_com])
+      store.all.should == [
+        Ghost::Host.new('foo.com', '123.123.123.123'),
+        Ghost::Host.new('bar.com', '127.0.0.1')
+      ]
+    end
+  end
+
+  describe "#find" do
+    it 'finds hosts matching a regex' do
+      cmd.stub(:list).and_return([dscl_foo_com, dscl_bar_com])
+      store.find(/.*/).should == store.all
+      store.find(/f/).should == [Ghost::Host.new('foo.com', '123.123.123.123')]
+    end
+  end
+
+  describe "#add" do
+    let(:host) { Ghost::Host.new('foo.com', '123.123.123.123') }
+
+    it 'returns true' do
+      store.add(host).should be_true
+    end
+
+    # In order to make this run off OS X and without root, have to use an
+    # expectation... I think?
+    it 'adds the host' do
+      cmd.should_receive(:create).with('localhost', 'foo.com', '123.123.123.123')
+      store.add(host)
+    end
+  end
+
+  describe "#delete" do
+    before do
+      store.stub(:all).and_return [
+        Ghost::Host.new('foo.com', '127.0.0.1'),
+        Ghost::Host.new('fo.com', '127.0.0.1'),
+        Ghost::Host.new('fooo.com', '127.0.0.2')
+      ]
+    end
+
+    context 'using a Ghost::Host to identify host' do
+      context 'and the IP does not match an entry' do
+        let(:host) { Ghost::Host.new("foo.com", "127.0.0.2") }
+
+        it 'returns empty array' do
+          store.delete(host).should == []
+        end
+
+        it 'has no effect' do
+          store.delete(host)
+          cmd.should_not_receive(:delete)
+        end
+      end
+
+      context 'and the IP matches an entry' do
+        let(:host) { Ghost::Host.new("foo.com", "127.0.0.1") }
+
+        it 'returns array of deleted hosts' do
+          store.delete(host).should == [host]
+        end
+
+        # In order to make this run off OS X and without root, have to use an
+        # expectation... I think?
+        it 'deletes the host' do
+          cmd.should_receive(:delete).with('localhost', 'foo.com')
+          store.delete(host)
+        end
+      end
+    end
+
+    context 'using a regex to identify hosts' do
+      let(:host) { /fo*\.com/ }
+
+      it 'returns array of removed hosts' do
+        store.delete(host).should == [
+          Ghost::Host.new('fo.com',   '127.0.0.1'),
+          Ghost::Host.new('foo.com',  '127.0.0.1'),
+          Ghost::Host.new('fooo.com', '127.0.0.2')
+        ]
+      end
+
+      it 'deletes the hosts' do
+        cmd.should_receive(:delete).with('localhost', 'fo.com')
+        cmd.should_receive(:delete).with('localhost', 'foo.com')
+        cmd.should_receive(:delete).with('localhost', 'fooo.com')
+        store.delete(host)
+      end
+    end
+
+    context 'using a string to identify host' do
+      let(:host) { "foo.com" }
+
+      it 'returns array of removed hosts' do
+        store.delete(host).should == [Ghost::Host.new('foo.com', '127.0.0.1')]
+      end
+
+      it 'removes the host from the file' do
+        cmd.should_receive(:delete).with('localhost', 'foo.com')
+        store.delete(host)
+      end
+    end
+  end
+
+  describe "#empty" do
+    it 'deletes all the entries' do
+      store.stub(:all => [Ghost::Host.new('foo'), Ghost::Host.new('bar')])
+      cmd.should_receive(:delete).with('localhost', 'foo')
+      cmd.should_receive(:delete).with('localhost', 'bar')
+      store.empty
+    end
+  end
+end

data/spec/ghost/store/hosts_file_store_spec.rb

@@ -0,0 +1,316 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+require 'ghost/store/hosts_file_store'
+
+require 'tmpdir'
+
+describe Ghost::Store::HostsFileStore do
+  def write(content)
+    File.open(file_path, 'w') { |f| f.write(content) }
+  end
+
+  def read
+    File.read(file_path)
+  end
+
+  def no_write
+    File.any_instance.stub(:reopen).with(anything, /[aw]/).and_raise("no writing!")
+    File.any_instance.stub(:puts).and_raise("no writing!")
+    File.any_instance.stub(:print).and_raise("no writing!")
+    File.any_instance.stub(:write).and_raise("no writing!")
+    File.any_instance.stub(:<<).and_raise("no writing!")
+    File.any_instance.stub(:flush).and_raise("no writing!")
+  end
+
+  subject { store }
+
+  let(:file_path) { File.join(Dir.tmpdir, "etc_hosts.#{Process.pid}.#{rand(9999)}") }
+  let(:store)     { described_class.new(file_path) }
+  let(:contents) do
+    <<-EOF.unindent
+    127.0.0.1 localhost localhost.localdomain
+    EOF
+  end
+
+  before { write(contents) }
+
+  it 'manages the default file of /etc/hosts when no file path is provided' do
+    described_class.new.path.should == "/etc/hosts"
+  end
+
+  it 'manages the file at the provided path when given' do
+    described_class.new('xyz').path.should == 'xyz'
+  end
+
+  describe "#all" do
+    context 'with no ghost-managed hosts in the file' do
+      it 'returns no hosts' do
+        store.all.should == []
+      end
+    end
+
+    context 'with some ghost-managed hosts in the file' do
+      let(:contents) do
+        <<-EOF.gsub(/^\s+/,'')
+        127.0.0.1 localhost localhost.localdomain
+        # ghost start
+        1.2.3.4 bjeanes.com
+        2.3.4.5 my-app.com subdomain.my-app.com
+        # ghost end
+        EOF
+      end
+
+      it 'returns an array with one Ghost::Host per ghost-managed host in the hosts file' do
+        store.all.should == [
+          Ghost::Host.new('bjeanes.com', '1.2.3.4'),
+          Ghost::Host.new('my-app.com', '2.3.4.5'),
+          Ghost::Host.new('subdomain.my-app.com', '2.3.4.5')
+        ]
+      end
+
+      it "shouldn't write to the file" do
+        no_write
+        store.all
+      end
+    end
+  end
+
+  describe "#find" do
+    let(:contents) do
+      <<-EOF.gsub(/^\s+/,'')
+      # ghost start
+      1.2.3.4 bjeanes.com
+      2.3.4.5 my-app.com subdomain.my-app.com
+      # ghost end
+      EOF
+    end
+
+    it "finds hosts matching a regex" do
+      store.find(/.*/).should == store.all
+      store.find(/my-app\.com$/i).should == [
+        Ghost::Host.new('my-app.com', '2.3.4.5'),
+        Ghost::Host.new('subdomain.my-app.com', '2.3.4.5')
+      ]
+    end
+  end
+
+  describe "#add" do
+    let(:host) { Ghost::Host.new("google.com", "127.0.0.1") }
+
+    context 'with no ghost-managed hosts in the file' do
+      it 'returns true' do
+        store.add(host).should be_true
+      end
+
+      it 'adds the new host between delimeters' do
+        store.add(host)
+        read.should == <<-EOF.gsub(/^\s+/,'')
+          127.0.0.1 localhost localhost.localdomain
+          # ghost start
+          127.0.0.1 google.com
+          # ghost end
+        EOF
+      end
+    end
+
+    context 'with existing ghost-managed hosts in the file' do
+      let(:contents) do
+        <<-EOF.gsub(/^\s+/,'')
+          127.0.0.1 localhost localhost.localdomain
+          # ghost start
+          192.168.1.1 github.com
+          # ghost end
+        EOF
+      end
+
+      context 'when adding to an existing IP' do
+        before { host.ip = '192.168.1.1' }
+
+        it 'adds to existing entry between tokens, listing host names in alphabetical order' do
+          store.add(host)
+          read.should == <<-EOF.gsub(/^\s+/,'')
+            127.0.0.1 localhost localhost.localdomain
+            # ghost start
+            192.168.1.1 github.com google.com
+            # ghost end
+          EOF
+        end
+
+        it 'returns true' do
+          store.add(host).should be_true
+        end
+      end
+
+      context 'when adding a new IP' do
+        it 'adds new entry between tokens, in numerical order' do
+          store.add(host)
+          read.should == <<-EOF.gsub(/^\s+/,'')
+            127.0.0.1 localhost localhost.localdomain
+            # ghost start
+            127.0.0.1 google.com
+            192.168.1.1 github.com
+            # ghost end
+          EOF
+        end
+
+        it 'returns true' do
+          store.add(host).should be_true
+        end
+      end
+    end
+  end
+
+  describe "#delete" do
+    context 'with no ghost-managed hosts in the file' do
+      let(:host) { Ghost::Host.new("localhost", "127.0.0.1") }
+
+      it 'returns empty array' do
+        store.delete(host).should == []
+      end
+
+      it 'has no effect' do
+        store.delete(host)
+        read.should == contents
+      end
+    end
+
+    context 'with existing ghost-managed hosts in the file' do
+      let(:contents) do
+        <<-EOF.gsub(/^\s+/,'')
+          127.0.0.1 localhost localhost.localdomain
+          # ghost start
+          127.0.0.1 google.com
+          127.0.0.2 gooogle.com
+          192.168.1.1 github.com
+          # ghost end
+        EOF
+      end
+
+      context 'when deleting one of the ghost entries' do
+        context 'using a Ghost::Host to identify host' do
+          context 'and the IP does not match an entry' do
+            let(:host) { Ghost::Host.new("google.com", "127.0.0.2") }
+
+            it 'returns empty array' do
+              store.delete(host).should == []
+            end
+
+            it 'has no effect' do
+              store.delete(host)
+              read.should == contents
+            end
+          end
+
+          context 'and the IP matches an entry' do
+            let(:host) { Ghost::Host.new("google.com", "127.0.0.1") }
+
+            it 'returns array of removed hosts' do
+              store.delete(host).should == [Ghost::Host.new('google.com', '127.0.0.1')]
+            end
+
+            it 'removes the host from the file' do
+              store.delete(host)
+              read.should == <<-EOF.gsub(/^\s+/,'')
+                127.0.0.1 localhost localhost.localdomain
+                # ghost start
+                127.0.0.2 gooogle.com
+                192.168.1.1 github.com
+                # ghost end
+              EOF
+            end
+          end
+        end
+
+        context 'using a regex to identify hosts' do
+          let(:host) { /go*gle\.com/ }
+
+          it 'returns array of removed hosts' do
+            store.delete(host).should == [
+              Ghost::Host.new('google.com',  '127.0.0.1'),
+              Ghost::Host.new('gooogle.com', '127.0.0.2')
+            ]
+          end
+
+          it 'removes the host from the file' do
+            store.delete(host)
+            read.should == <<-EOF.gsub(/^\s+/,'')
+              127.0.0.1 localhost localhost.localdomain
+              # ghost start
+              192.168.1.1 github.com
+              # ghost end
+            EOF
+          end
+        end
+
+        context 'using a string to identify host' do
+          let(:host) { "google.com" }
+
+          it 'returns array of removed hosts' do
+            store.delete(host).should == [Ghost::Host.new('google.com', '127.0.0.1')]
+          end
+
+          it 'removes the host from the file' do
+            store.delete(host)
+            read.should == <<-EOF.gsub(/^\s+/,'')
+              127.0.0.1 localhost localhost.localdomain
+              # ghost start
+              127.0.0.2 gooogle.com
+              192.168.1.1 github.com
+              # ghost end
+            EOF
+          end
+        end
+      end
+
+      context 'when trying to delete a non-ghost entry' do
+        let(:host) { Ghost::Host.new("localhost") }
+
+        it 'returns false' do
+          store.delete(host).should == []
+        end
+
+        it 'has no effect' do
+          store.delete(host)
+          read.should == contents
+        end
+      end
+    end
+  end
+
+  describe "#empty" do
+    context 'with no ghost-managed hosts in the file' do
+      it 'returns false' do
+        store.empty.should be_false
+      end
+
+      it 'has no effect' do
+        store.empty
+        read.should == contents
+      end
+    end
+
+    context 'with existing ghost-managed hosts in the file' do
+      let(:contents) do
+        <<-EOF.gsub(/^\s+/,'')
+          127.0.0.1 localhost localhost.localdomain
+          # ghost start
+          127.0.0.1 google.com
+          192.168.1.1 github.com
+          # ghost end
+        EOF
+      end
+
+      context 'when deleting one of the ghost entries' do
+        it 'returns true' do
+          store.empty.should be_true
+        end
+
+        it 'removes the host from the file' do
+          store.empty
+          read.should == <<-EOF.gsub(/^\s+/,'')
+            127.0.0.1 localhost localhost.localdomain
+          EOF
+        end
+      end
+    end
+  end
+end