hosts 0.1.0

data/spec/aef/hosts/file_spec.rb

@@ -0,0 +1,290 @@
+# encoding: UTF-8
+=begin
+Copyright Alexander E. Fischer <aef@raxys.net>, 2012
+
+This file is part of Hosts.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+require 'spec_helper'
+
+describe Aef::Hosts::File do
+  let(:hosts_file) { fixtures_dir + 'linux_hosts' }
+  let(:file) { described_class.new }
+
+  describe "path attribute" do
+    it "should exist" do
+      file.should respond_to(:path)
+    end
+    
+    it "should be nil by default" do
+      file.path.should be_nil
+    end
+  
+    it "should be settable" do
+      file.should respond_to(:path=)
+  
+      file.path = Pathname.pwd
+  
+      file.path.should == Pathname.pwd
+    end
+  
+    it "should automatically convert strings to Pathname objects when set" do
+      file.path = Dir.pwd
+
+      file.path.should == Pathname.pwd
+    end
+
+    it "should be settable through the constructor" do
+      file = Aef::Hosts::File.new(Pathname.pwd)
+
+      file.path.should == Pathname.pwd
+    end
+  end
+  
+  describe "reading from file" do
+    before(:each) do
+      file.path = hosts_file
+    end
+  
+    it "should be possible through the .read method" do
+      file = Aef::Hosts::File.read(hosts_file)
+
+      file.elements.should_not be_empty
+      file.path.should eql Pathname.new(hosts_file)
+    end
+
+    it "should be possible through the #read method" do
+      file.should respond_to(:read)
+
+      expect {
+        file.read.should == file
+      }.to change{ file.elements.length }
+    end
+    
+    it "should allow the path attribute to be temporarily overridden" do
+      file.path = nil
+      
+      return_value = file.read(hosts_file)
+      return_value.should == file
+    end
+  end
+  
+  describe "parsing" do
+    before(:each) do
+      file.path = hosts_file
+    end
+  
+    it "should be possible through the .parse method" do
+      file = Aef::Hosts::File.parse(hosts_file.read)
+
+      file.elements.should_not be_empty
+    end
+
+    it "should be possible through the #parse method" do
+      file.should respond_to(:parse)
+
+      expect {
+        file.parse(hosts_file.read).should == file
+      }.to change{ file.elements.length }      
+    end
+
+    it "should be able to parse an empty element" do
+      file.parse(<<-HOSTS)
+
+      HOSTS
+
+      file.elements.should have(1).item
+      file.elements.first.should be_a(Aef::Hosts::EmptyElement)
+      file.elements.first.cache_filled?.should be_true
+    end
+    
+    it "should be able to parse a comment" do
+      file.parse(<<-HOSTS)
+# test
+      HOSTS
+
+      file.elements.should have(1).item
+      element = file.elements.first
+      element.should be_a(Aef::Hosts::Comment)
+      element.cache_filled?.should be_true
+      element.comment.should eql ' test'
+    end
+
+    it "should be able to parse an entry" do
+      file.parse(<<-HOSTS)
+10.23.5.17  myhost  myhost.mydomain    altname  # entry
+      HOSTS
+
+      file.elements.should have(1).item
+      element = file.elements.first
+      element.should be_a(Aef::Hosts::Entry)
+      element.cache_filled?.should be_true
+      element.address.should eql '10.23.5.17'
+      element.name.should eql 'myhost'
+      element.aliases.should eql ['myhost.mydomain', 'altname']
+      element.comment.should eql ' entry'
+    end
+
+    it "should be able to parse a section" do
+      file.parse(<<-HOSTS)
+# -----BEGIN SECTION test-----
+# -----END SECTION test-----
+      HOSTS
+
+      file.elements.should have(1).item
+      element = file.elements.first
+      element.should be_a(Aef::Hosts::Section)
+      element.cache_filled?.should be_true
+      element.name.should eql 'test'
+    end
+
+    it "should complain about nested sections" do
+      hosts = <<-HOSTS
+# -----BEGIN SECTION outer-----
+# -----BEGIN SECTION inner-----
+# -----END SECTION inner-----
+# -----END SECTION outer-----
+      HOSTS
+
+      expect {
+        file.parse(hosts)
+      }.to raise_error(Aef::Hosts::ParserError, "Invalid cascading of sections. Cannot start new section 'inner' without first closing section 'outer' on line 2.")
+    end
+
+    it "should complain about closing the wrong section" do
+      hosts = <<-HOSTS
+# -----BEGIN SECTION correct-----
+# -----END SECTION incorrect-----
+      HOSTS
+
+      expect {
+        file.parse(hosts)
+      }.to raise_error(Aef::Hosts::ParserError, "Invalid closing of section. Found attempt to close section 'incorrect' in body of section 'correct' on line 2.")
+    end
+  end
+
+  context "#invalidate_cache!" do
+    it "should clear the cache of the file's elements" do
+      child_a = 'markov'
+      child_b = 'chainey'
+
+      child_a.should_receive(:invalidate_cache!)
+      child_b.should_receive(:invalidate_cache!)
+
+      file.elements << child_a
+      file.elements << child_b
+
+      file.invalidate_cache!
+    end
+  end
+
+  context "#inspect" do
+    it "should be able to generate a debugging String" do
+      file.inspect.should eql %{#<Aef::Hosts::File: path=nil elements=[]>}
+    end
+
+    it "should be able to generate a debugging String with path" do
+      file.path = hosts_file
+      file.inspect.should eql %{#<Aef::Hosts::File: path=#<Pathname:#{hosts_file}> elements=[]>}
+    end
+
+    it "should be able to generate a debugging String with cascaded elements" do
+      section = Aef::Hosts::Section.new('new section', :elements => [
+        'fnord',
+        'eris'
+      ])
+
+      file.elements << section
+      file.elements << 'hagbard'
+
+      file.inspect.should eql <<-STRING.chomp
+#<Aef::Hosts::File: path=nil elements=[
+  #<Aef::Hosts::Section: name="new section" elements=[
+    "fnord",
+    "eris"
+  ]>,
+  "hagbard"
+]>
+      STRING
+    end
+
+    it "should be able to generate a debugging String with elements" do
+      file.elements << 'fnord'
+      file.elements << 'eris'
+      file.inspect.should eql <<-STRING.chomp
+#<Aef::Hosts::File: path=nil elements=[
+  "fnord",
+  "eris"
+]>
+      STRING
+    end
+  end
+  
+  describe "string generation" do
+    it "should produce unchanged output if nothing changed" do
+      file.path = hosts_file
+      file.read
+      
+      file.to_s.should == hosts_file.read
+    end
+    
+    it "should be able to re-encode the linebreaks of generated output" do
+      hosts_file = fixtures_dir + 'windows_hosts'
+      file.path = hosts_file
+      file.read
+      
+      original_document = hosts_file.read
+      
+      file.to_s.should_not == original_document
+      file.to_s(:linebreak_encoding => :windows).should == original_document
+    end
+  end
+
+  describe "writing to file" do
+    before(:each) do
+      @dir = create_temp_dir
+    end
+
+    after(:each) do
+      @dir.rmtree
+    end
+
+    it "should be possible through the #write method" do
+      file.should respond_to(:write)
+
+      result_file = @dir + 'hosts'
+      data = hosts_file.read
+
+      file.parse(data)
+      file.path = result_file
+      file.write
+      
+      result_file.read.should == data
+    end
+    
+    it "should allow the path attribute to be temporarily overridden" do
+      result_file = @dir + 'hosts'
+      wrong_file  = @dir + 'wrong_file'
+      data = hosts_file.read
+
+      file.parse(data)
+      file.path = wrong_file
+
+      file.write(:path => result_file)
+
+      result_file.read.should == data
+    end
+  end
+end

data/spec/aef/hosts/helpers_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Aef::Hosts::Helpers do
+  include Aef::Hosts::Helpers
+
+  let(:model) {
+    model = OpenStruct.new(
+      :name => 'test',
+      :cache_filled => true,
+      :elements => ['fnord', 'eris']
+    )
+
+    def model.cache_filled?
+      cache_filled
+    end
+
+    model
+  }
+
+  context "#validate_options" do
+    it "should accept options with a subset of valid option keys" do
+      options = {:valid1 => 123, :valid2 => 456} 
+
+      expect {
+        validate_options(options, :valid1, :valid2, :valid3)
+      }.not_to raise_error
+    end
+
+    it "should accept options with exactly the valid option keys" do
+      options = {:valid1 => 123, :valid2 => 456, :valid3 => 789} 
+
+      expect {
+        validate_options(options, :valid1, :valid2, :valid3)
+      }.not_to raise_error
+    end
+
+    it "should deny options with invalid option keys" do
+      options = {:valid1 => 123, :invalid => 'test'} 
+  
+      expect {
+        validate_options(options, :valid1, :valid2, :valid3)
+      }.to raise_error(ArgumentError, 'Invalid option keys: :invalid')
+    end
+  end
+
+  context "#to_pathname" do
+    it "should return nil when nil is given" do
+      to_pathname(nil).should be_nil
+    end
+
+    it "should return a Pathname when a String is given" do
+      to_pathname('abc/def').should eql Pathname.new('abc/def')
+    end
+    
+    it "should return a Pathname when a Pathname is given" do
+      to_pathname(Pathname.new('abc/def')).should eql Pathname.new('abc/def')
+    end
+  end
+
+  context "generate_inspect" do
+    it "should be able to render a minimal inspect output" do
+      generate_inspect(model).should eql %{#<OpenStruct>}
+    end
+
+    it "should be able to render a normal attribute in inspect output" do
+      generate_inspect(model, :name).should eql %{#<OpenStruct: name="test">}
+    end
+
+    it "should be able to render an attribute by custom String in inspect output" do
+      generate_inspect(model, 'abc=123').should eql %{#<OpenStruct: abc=123>}
+    end
+
+    it "should be able to render a special cache attribute in inspect output" do
+      generate_inspect(model, :cache).should eql %{#<OpenStruct: cached!>}
+    end
+
+    it "should not render a special cache attribute in inspect output if cache is not filled" do
+      model.cache_filled = false
+      generate_inspect(model, :cache).should eql %{#<OpenStruct>}
+    end
+
+    it "should be able to render elements in inspect output" do
+      generate_inspect(model, :elements).should eql <<-STRING.chomp
+#<OpenStruct: elements=[
+  "fnord",
+  "eris"
+]>
+      STRING
+    end
+  end
+
+  context "generate_elements_partial" do
+    it "should be able to render elements in inspect output" do
+      generate_elements_partial(['fnord', 'eris']).should eql <<-STRING.chomp
+elements=[
+  "fnord",
+  "eris"
+]
+      STRING
+    end 
+  end
+end

data/spec/aef/hosts/section_spec.rb

@@ -0,0 +1,299 @@
+# encoding: UTF-8
+=begin
+Copyright Alexander E. Fischer <aef@raxys.net>, 2012
+
+This file is part of Hosts.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+=end
+
+require 'spec_helper'
+
+describe Aef::Hosts::Section do
+  let(:element) { described_class.new('some name') }
+
+  describe "name attribute" do
+    it "should exist" do
+      element.should respond_to(:name)
+    end
+
+    it "should be settable" do
+      element.should respond_to(:name=)
+
+      element.name = 'demo section'
+
+      element.name.should == 'demo section'
+    end
+
+    it "should be settable through the constructor" do
+      element = Aef::Hosts::Section.new('demo section')
+
+      element.name.should == 'demo section'
+    end
+    
+    it "should be a mandatory argument of the constructor" do
+      expect {
+        element = Aef::Hosts::Section.new(nil)
+      }.to raise_error(ArgumentError)
+    end
+    
+    it "should flag the object as changed if modified" do
+      element = Aef::Hosts::Section.new('some name', :cache => {
+        :header => "# -----BEGIN SECTION some name-----    \n",
+        :footer => "# -----END SECTION some name-----    \n"
+      })
+
+      expect {
+        element.name = 'demo section'
+      }.to change{ element.cache_filled? }.from(true).to(false)
+    end
+  end
+  
+  describe "elements attribute" do
+    it "should exist" do
+      element.should respond_to(:elements)
+    end
+
+    it "should be settable" do
+      element.should respond_to(:elements=)
+
+      element.elements = ['abc', 'def']
+
+      element.elements.should eql ['abc', 'def']
+    end
+
+    it "should be settable through the constructor" do
+      element = Aef::Hosts::Section.new('name', :elements => ['abc', 'def'])
+
+      element.elements.should eql ['abc', 'def']
+    end
+    
+    it "should flag the object as changed if modified" do
+      child_element = 'abc'
+      element = Aef::Hosts::Section.new('some name', :cache => {
+        :header => "# -----BEGIN SECTION some name-----    \n",
+        :footer => "# -----END SECTION some name-----    \n"
+      }, :elements => [child_element])
+
+      child_element.should_not_receive(:invalidate_cache!)
+
+      expect {
+        element.elements = [child_element, 'def']
+      }.to change{ element.cache_filled? }.from(true).to(false)
+    end
+  end
+  
+  describe "cache attribute" do
+    it "should exist" do
+      element.should respond_to(:cache)
+    end
+
+    it "should be nil by default" do
+      element.cache.should == {:footer => nil, :header => nil}
+    end
+
+    it "should not be allowed to be set" do
+      element.should_not respond_to(:cache=)
+    end
+
+    it "should be settable through the constructor" do
+      element = Aef::Hosts::Section.new('demo section', :cache => {
+          :header => "# -----BEGIN SECTION demo section-----    \n",
+          :footer => "# -----END SECTION demo section-----\t\t\t\n"
+      })
+      
+      element.cache.should == {
+        :header => "# -----BEGIN SECTION demo section-----    \n",
+        :footer => "# -----END SECTION demo section-----\t\t\t\n"
+      }
+    end
+
+    it "should be correctly reported as empty by cache_filled?" do
+      element.should respond_to(:cache_filled?)
+
+      element.cache_filled?.should be_false
+    end
+
+    it "should be correctly reported as filled by cache_filled?" do
+      element = Aef::Hosts::Section.new('demo section', :cache => {
+          :header => "# -----BEGIN SECTION demo section-----    \n",
+          :footer => "# -----END SECTION demo section-----\t\t\t\n"
+      })
+      
+      element.should respond_to(:cache_filled?)
+
+      element.cache_filled?.should be_true
+    end
+
+    it "should be invalidatable" do
+      element = Aef::Hosts::Section.new('demo section', :cache => {
+          :header => "# -----BEGIN SECTION demo section-----    \n",
+          :footer => "# -----END SECTION demo section-----\t\t\t\n"
+      })
+
+      element.invalidate_cache!
+
+      element.cache[:header].should be_nil
+      element.cache[:footer].should be_nil
+    end
+  end
+
+  context "#invalidate_cache!" do
+    it "should clear the cache of the section and its elements" do
+      child_a = 'markov'
+      child_b = 'chainey'
+
+      child_a.should_receive(:invalidate_cache!)
+      child_b.should_receive(:invalidate_cache!)
+
+      element.elements << child_a
+      element.elements << child_b
+
+      element.invalidate_cache!
+    end
+
+    it "should clear the cache of the section only if :only_section is set" do
+      child_a = 'markov'
+      child_b = 'chainey'
+
+      child_a.should_not_receive(:invalidate_cache!)
+      child_b.should_not_receive(:invalidate_cache!)
+
+      element.elements << child_a
+      element.elements << child_b
+
+      element.invalidate_cache!(:only_section => true)
+    end
+  end
+
+  context "#inspect" do
+    it "should be able to generate a debugging String" do
+      element.inspect.should eql %{#<Aef::Hosts::Section: name="some name" elements=[]>}
+    end
+
+    it "should be able to generate a debugging String with elements" do
+      element.elements << 'fnord'
+      element.elements << 'eris'
+      element.inspect.should eql <<-STRING.chomp
+#<Aef::Hosts::Section: name="some name" elements=[
+  "fnord",
+  "eris"
+]>
+      STRING
+    end
+
+    it "should be able to generate a debugging String with cache filled" do
+      element = Aef::Hosts::Section.new('demo section', :cache => {:header => 'abc', :footer => 'xyz'})
+      element.inspect.should eql %{#<Aef::Hosts::Section: name="demo section" cached! elements=[]>}
+    end
+  end
+
+  describe "string generation" do
+    before(:all) do
+      class Aef::Hosts::ChildElement < Aef::Hosts::Element
+        def generate_string(options = {})
+          "uncached element representation\n"
+        end
+        
+        def cache=(cache)
+          @cache = cache
+        end
+      end
+    end
+  
+    it "should generate a new representation if no cache is available" do
+      element = Aef::Hosts::Section.new('demo section')
+
+      element.to_s.should == <<-EOS
+# -----BEGIN SECTION demo section-----
+# -----END SECTION demo section-----
+      EOS
+    end
+    
+    it "should respond with a duplicate of the cached representation if cache is filled" do
+      element = Aef::Hosts::Section.new('demo section', :cache => {
+        :header => "# -----BEGIN SECTION demo section-----    \n",
+        :footer => "# -----END SECTION demo section-----    \n"
+      })
+
+      element.to_s.should == <<-EOS
+# -----BEGIN SECTION demo section-----    
+# -----END SECTION demo section-----    
+      EOS
+
+      # Should not be identical
+      element.to_s.should_not equal(element.cache[:footer])
+      element.to_s.should_not equal(element.cache[:header])
+    end
+
+    it "should respond with a duplicate of the cached representation if cache is filled" do
+      element = Aef::Hosts::Section.new('demo section', :cache => {
+        :header => "# -----BEGIN SECTION demo section-----    \n",
+        :footer => "# -----END SECTION demo section-----    \n"
+      })
+
+      element.to_s(:force_generation => true).should == <<-EOS
+# -----BEGIN SECTION demo section-----
+# -----END SECTION demo section-----
+      EOS
+    end
+    
+    it "should correctly display including elements" do
+      sub_element_without_cache    = Aef::Hosts::ChildElement.new
+      sub_element_with_cache       = Aef::Hosts::ChildElement.new
+      sub_element_with_cache.cache = "cached element representation\n"
+    
+      element = Aef::Hosts::Section.new('demo section',
+        :elements => [
+          sub_element_with_cache,
+          sub_element_without_cache
+        ],
+        :cache => {
+          :header => "# -----BEGIN SECTION demo section-----    \n",
+          :footer => "# -----END SECTION demo section-----    \n"
+        }
+      )
+
+      element.to_s.should == <<-EOS
+# -----BEGIN SECTION demo section-----    
+cached element representation
+uncached element representation
+# -----END SECTION demo section-----    
+      EOS
+    end
+
+    it "should correctly display including elements with forced generation" do
+      sub_element_without_cache    = Aef::Hosts::ChildElement.new
+      sub_element_with_cache       = Aef::Hosts::ChildElement.new
+      sub_element_with_cache.cache = "cached element representation\n"
+    
+      element = Aef::Hosts::Section.new('demo section',
+        :elements => [
+          sub_element_with_cache,
+          sub_element_without_cache
+        ],
+        :cache => {
+          :header => "# -----BEGIN SECTION demo section-----    \n",
+          :footer => "# -----END SECTION demo section-----    \n"
+        }
+      )
+
+      element.to_s(:force_generation => true).should == <<-EOS
+# -----BEGIN SECTION demo section-----
+uncached element representation
+uncached element representation
+# -----END SECTION demo section-----
+      EOS
+    end
+  end
+end